package org.linlinjava.litemall.wx.service;

import com.github.binarywang.wxpay.bean.notify.WxPayNotifyResponse;
import com.github.binarywang.wxpay.bean.notify.WxPayOrderNotifyResult;
import com.github.binarywang.wxpay.bean.order.WxPayMpOrderResult;
import com.github.binarywang.wxpay.bean.order.WxPayMwebOrderResult;
import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderRequest;
import com.github.binarywang.wxpay.bean.result.BaseWxPayResult;
import com.github.binarywang.wxpay.constant.WxPayConstants;
import com.github.binarywang.wxpay.exception.WxPayException;
import com.github.binarywang.wxpay.service.WxPayService;
import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.linlinjava.litemall.core.express.ExpressService;
import org.linlinjava.litemall.core.express.dao.ExpressInfo;
import org.linlinjava.litemall.core.notify.NotifyService;
import org.linlinjava.litemall.core.notify.NotifyType;
import org.linlinjava.litemall.core.qcode.QCodeService;
import org.linlinjava.litemall.core.system.SystemConfig;
import org.linlinjava.litemall.core.task.TaskService;
import org.linlinjava.litemall.core.util.DateTimeUtil;
import org.linlinjava.litemall.core.util.JacksonUtil;
import org.linlinjava.litemall.core.util.ResponseUtil;
import org.linlinjava.litemall.db.domain.*;
import org.linlinjava.litemall.db.service.*;
import org.linlinjava.litemall.db.util.CouponUserConstant;
import org.linlinjava.litemall.db.util.GrouponConstant;
import org.linlinjava.litemall.db.util.OrderHandleOption;
import org.linlinjava.litemall.db.util.OrderUtil;
import org.linlinjava.litemall.core.util.IpUtil;
import org.linlinjava.litemall.wx.dto.AlipayNotifyParam;
import org.linlinjava.litemall.wx.task.OrderUnpaidTask;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.*;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static org.linlinjava.litemall.wx.util.WxResponseCode.*;

/**
 * 订单服务
 *
 * <p>
 * 订单状态：
 * 101 订单生成，未支付；102，下单后未支付用户取消；103，下单后未支付超时系统自动取消
 * 201 支付完成，商家未发货；202，订单生产，已付款未发货，但是退款取消；
 * 301 商家发货，用户未确认；
 * 401 用户确认收货； 402 用户没有确认收货超过一定时间，系统自动确认收货；
 *
 * <p>
 * 用户操作：
 * 当101用户未付款时，此时用户可以进行的操作是取消订单，或者付款操作
 * 当201支付完成而商家未发货时，此时用户可以取消订单并申请退款
 * 当301商家已发货时，此时用户可以有确认收货的操作
 * 当401用户确认收货以后，此时用户可以进行的操作是删除订单，评价商品，申请售后，或者再次购买
 * 当402系统自动确认收货以后，此时用户可以删除订单，评价商品，申请售后，或者再次购买
 */
@Service
public class WxOrderService {
    private final Log logger = LogFactory.getLog(WxOrderService.class);

    @Autowired
    private LitemallUserService userService;
    @Autowired
    private LitemallOrderService orderService;
    @Autowired
    private LitemallOrderGoodsService orderGoodsService;
    @Autowired
    private LitemallAddressService addressService;
    @Autowired
    private LitemallCartService cartService;
    @Autowired
    private LitemallRegionService regionService;
    @Autowired
    private LitemallGoodsProductService productService;
    @Autowired
    private WxPayService wxPayService;
    @Autowired
    private NotifyService notifyService;
    @Autowired
    private LitemallGrouponRulesService grouponRulesService;
    @Autowired
    private LitemallGrouponService grouponService;
    @Autowired
    private QCodeService qCodeService;
    @Autowired
    private ExpressService expressService;
    @Autowired
    private LitemallCommentService commentService;
    @Autowired
    private LitemallCouponService couponService;
    @Autowired
    private LitemallCouponUserService couponUserService;
    @Autowired
    private CouponVerifyService couponVerifyService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private LitemallAftersaleService aftersaleService;


    @Autowired
    private LitemallGoodsService litemallGoodsService;


    @Autowired
    private LitemallMoneyLogService litemallMoneyLogService;

    @Autowired
    private LitemallBaseService litemallBaseService;

    @Autowired
    private LitemallPointsRecordService pointsRecordService;

    /**
     * 建立一个  lock 轻锁  ，获得 sun  fsp 等等 ，还是建议使用异步 ，这是同步锁
     */
    private Lock lock = new ReentrantLock();

    /**
     * 订单列表
     *
     * @param userId   用户ID
     * @param showType 订单信息：
     *                 0，全部订单；
     *                 1，待付款；
     *                 2，待发货；
     *                 3，待收货；
     *                 4，待评价。
     * @param page     分页页数
     * @param limit    分页大小
     * @return 订单列表
     */
    public Object list(Integer userId, Integer showType, Integer page, Integer limit, String sort, String order) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }

        List<Short> orderStatus = OrderUtil.orderStatus(showType);
        List<LitemallOrder> orderList = orderService.queryByOrderStatus(userId, orderStatus, page, limit, sort, order);

        List<Map<String, Object>> orderVoList = new ArrayList<>(orderList.size());
        for (LitemallOrder o : orderList) {
            Map<String, Object> orderVo = new HashMap<>();
            orderVo.put("id", o.getId());
            orderVo.put("orderSn", o.getOrderSn());
            orderVo.put("actualPrice", o.getActualPrice());
            orderVo.put("orderStatusText", OrderUtil.orderStatusText(o));
            orderVo.put("handleOption", OrderUtil.build(o));
            orderVo.put("aftersaleStatus", o.getAftersaleStatus());
            orderVo.put("orderstatus", o.getOrderStatus());
            orderVo.put("payType", o.getPayType());
            LitemallGroupon groupon = grouponService.queryByOrderId(o.getId());
            if (groupon != null) {
                orderVo.put("isGroupin", true);
            } else {
                orderVo.put("isGroupin", false);
            }

            List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(o.getId());
            List<Map<String, Object>> orderGoodsVoList = new ArrayList<>(orderGoodsList.size());
            for (LitemallOrderGoods orderGoods : orderGoodsList) {
                Map<String, Object> orderGoodsVo = new HashMap<>();
                orderGoodsVo.put("id", orderGoods.getId());
                orderGoodsVo.put("goodsName", orderGoods.getGoodsName());
                orderGoodsVo.put("number", orderGoods.getNumber());
                orderGoodsVo.put("picUrl", orderGoods.getPicUrl());
                orderGoodsVo.put("specifications", orderGoods.getSpecifications());
                orderGoodsVo.put("price", orderGoods.getPrice());
                orderGoodsVo.put("goodid", orderGoods.getGoodsId());
                orderGoodsVoList.add(orderGoodsVo);
            }
            orderVo.put("goodsList", orderGoodsVoList);

            orderVoList.add(orderVo);
        }

        return ResponseUtil.okList(orderVoList, orderList);
    }

    /**
     * 订单详情
     *
     * @param userId  用户ID
     * @param orderId 订单ID
     * @return 订单详情
     */
    public Object detail(Integer userId, Integer orderId) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }

        // 订单信息
        LitemallOrder order = orderService.findById(userId, orderId);
        if (null == order) {
            return ResponseUtil.fail(ORDER_UNKNOWN, "订单不存在");
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.fail(ORDER_INVALID, "不是当前用户的订单");
        }
        Map<String, Object> orderVo = new HashMap<String, Object>();
        orderVo.put("id", order.getId());
        orderVo.put("orderSn", order.getOrderSn());
        orderVo.put("message", order.getMessage());
        orderVo.put("addTime", order.getAddTime());
        orderVo.put("consignee", order.getConsignee());
        orderVo.put("mobile", order.getMobile());
        orderVo.put("address", order.getAddress());
        orderVo.put("goodsPrice", order.getGoodsPrice());
        orderVo.put("couponPrice", order.getCouponPrice());
        orderVo.put("freightPrice", order.getFreightPrice());
        orderVo.put("actualPrice", order.getActualPrice());
        orderVo.put("orderStatusText", OrderUtil.orderStatusText(order));
        orderVo.put("handleOption", OrderUtil.build(order));
        orderVo.put("aftersaleStatus", order.getAftersaleStatus());
        orderVo.put("expCode", order.getShipChannel());
        orderVo.put("expName", expressService.getVendorName(order.getShipChannel()));
        orderVo.put("expNo", order.getShipSn());
        orderVo.put("payType", order.getPayType());

        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(order.getId());

        Map<String, Object> result = new HashMap<>();
        result.put("orderInfo", orderVo);
        result.put("orderGoods", orderGoodsList);

        // 订单状态为已发货且物流信息不为空
        //"YTO", "800669400640887922"
        if (order.getOrderStatus().equals(OrderUtil.STATUS_SHIP)) {
            ExpressInfo ei = expressService.getExpressInfo(order.getShipChannel(), order.getShipSn());
            if (ei == null) {
                result.put("expressInfo", new ArrayList<>());
            } else {
                result.put("expressInfo", ei);
            }
        } else {
            result.put("expressInfo", new ArrayList<>());
        }

        return ResponseUtil.ok(result);

    }

    /**
     * 提交订单
     * <p>
     * 1. 创建订单表项和订单商品表项;
     * 2. 购物车清空;
     * 3. 优惠券设置已用;
     * 4. 商品货品库存减少;
     * 5. 如果是团购商品，则创建团购活动表项。
     *
     * @param userId 用户ID
     * @param body   订单信息，{ cartId：xxx, addressId: xxx, couponId: xxx, message: xxx, grouponRulesId: xxx,  grouponLinkId: xxx}
     * @return 提交订单操作结果
     */
    @Transactional
    public Object submit(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        if (body == null) {
            return ResponseUtil.badArgument();
        }
        Integer cartId = JacksonUtil.parseInteger(body, "cartId");
        Integer addressId = JacksonUtil.parseInteger(body, "addressId");
        Integer couponId = JacksonUtil.parseInteger(body, "couponId");
        Integer userCouponId = JacksonUtil.parseInteger(body, "userCouponId");
        String message = JacksonUtil.parseString(body, "message");
        Integer grouponRulesId = JacksonUtil.parseInteger(body, "grouponRulesId");
        Integer grouponLinkId = JacksonUtil.parseInteger(body, "grouponLinkId");

        /**  自定义int支付类型 **/
        Integer paytype = 1;
        //如果是团购项目,验证活动是否有效
        if (grouponRulesId != null && grouponRulesId > 0) {
            LitemallGrouponRules rules = grouponRulesService.findById(grouponRulesId);
            //找不到记录
            if (rules == null) {
                return ResponseUtil.badArgument();
            }
            //团购规则已经过期
            if (rules.getStatus().equals(GrouponConstant.RULE_STATUS_DOWN_EXPIRE)) {
                return ResponseUtil.fail(GROUPON_EXPIRED, "团购已过期!");
            }
            //团购规则已经下线
            if (rules.getStatus().equals(GrouponConstant.RULE_STATUS_DOWN_ADMIN)) {
                return ResponseUtil.fail(GROUPON_OFFLINE, "团购已下线!");
            }

            if (grouponLinkId != null && grouponLinkId > 0) {
                //团购人数已满
                if (grouponService.countGroupon(grouponLinkId) >= (rules.getDiscountMember() - 1)) {
                    return ResponseUtil.fail(GROUPON_FULL, "团购活动人数已满!");
                }
                // NOTE
                // 这里业务方面允许用户多次开团，以及多次参团，
                // 但是会限制以下两点：
                // （1）不允许参加已经加入的团购
                if (grouponService.hasJoin(userId, grouponLinkId)) {
                    return ResponseUtil.fail(GROUPON_JOIN, "团购活动已经参加!");
                }
                // （2）不允许参加自己开团的团购
                LitemallGroupon groupon = grouponService.queryById(userId, grouponLinkId);
                // if(groupon.getCreatorUserId().equals(userId)){
                //     return ResponseUtil.fail(GROUPON_JOIN, "团购活动已经参加!");
                // }
                if (groupon != null) {
                    if (groupon.getCreatorUserId().equals(userId)) {
                        return ResponseUtil.fail(GROUPON_JOIN, "团购活动已经参加!");
                    }
                }
            }
        }

        if (cartId == null || addressId == null || couponId == null) {
            return ResponseUtil.badArgument();
        }

        // 收货地址
        LitemallAddress checkedAddress = addressService.query(userId, addressId);
        if (checkedAddress == null) {
            return ResponseUtil.badArgument();
        }

        // 团购优惠
        BigDecimal grouponPrice = new BigDecimal(0);
        LitemallGrouponRules grouponRules = grouponRulesService.findById(grouponRulesId);
        if (grouponRules != null) {
            grouponPrice = grouponRules.getDiscount();
        }

        // 货品价格
        List<LitemallCart> checkedGoodsList = null;
        if (cartId.equals(0)) {
            checkedGoodsList = cartService.queryByUidAndChecked(userId);
        } else {
            LitemallCart cart = cartService.findById(cartId);
            checkedGoodsList = new ArrayList<>(1);
            checkedGoodsList.add(cart);
        }

        if (checkedGoodsList.size() == 0) {
            return ResponseUtil.badArgumentValue();
        }

        BigDecimal checkedGoodsPrice = new BigDecimal(0);
        for (LitemallCart checkGoods : checkedGoodsList) {
            //  只有当团购规格商品ID符合才进行团购优惠
            if (grouponRules != null && grouponRules.getGoodsId().equals(checkGoods.getGoodsId())) {
                checkedGoodsPrice = checkedGoodsPrice.add(checkGoods.getPrice().subtract(grouponPrice).multiply(new BigDecimal(checkGoods.getNumber())));
            } else {
                checkedGoodsPrice = checkedGoodsPrice.add(checkGoods.getPrice().multiply(new BigDecimal(checkGoods.getNumber())));
            }
        }

        // 获取可用的优惠券信息
        // 使用优惠券减免的金额
        BigDecimal couponPrice = new BigDecimal(0);
        // 如果couponId=0则没有优惠券，couponId=-1则不使用优惠券
        if (couponId != 0 && couponId != -1) {
            LitemallCoupon coupon = couponVerifyService.checkCoupon(userId, couponId, userCouponId, checkedGoodsPrice, checkedGoodsList);
            if (coupon == null) {
                return ResponseUtil.badArgumentValue();
            }
            couponPrice = coupon.getDiscount();
        }


        // 根据订单商品总价计算运费，满足条件（例如88元）则免运费，否则需要支付运费（例如8元）；
        BigDecimal freightPrice = new BigDecimal(0);
        if (checkedGoodsPrice.compareTo(SystemConfig.getFreightLimit()) < 0) {
            freightPrice = SystemConfig.getFreight();
        }

        // 可以使用的其他钱，例如用户积分
        BigDecimal integralPrice = new BigDecimal(0);

        // 订单费用
        BigDecimal orderTotalPrice = checkedGoodsPrice.add(freightPrice).subtract(couponPrice).max(new BigDecimal(0));
        // 最终支付费用
        BigDecimal actualPrice = orderTotalPrice.subtract(integralPrice);

        Integer orderId = null;
        LitemallOrder order = null;
        // 订单
        order = new LitemallOrder();
        order.setUserId(userId);
        order.setOrderSn(orderService.generateOrderSn(userId));
        order.setOrderStatus(OrderUtil.STATUS_CREATE);
        order.setConsignee(checkedAddress.getName());
        order.setMobile(checkedAddress.getTel());
        order.setMessage(message);
        String detailedAddress = checkedAddress.getProvince() + checkedAddress.getCity() + checkedAddress.getCounty() + " " + checkedAddress.getAddressDetail();
        order.setAddress(detailedAddress);
        order.setGoodsPrice(checkedGoodsPrice);
        order.setFreightPrice(freightPrice);
        order.setCouponPrice(couponPrice);
        order.setIntegralPrice(integralPrice);
        order.setOrderPrice(orderTotalPrice);
        order.setActualPrice(actualPrice);

        // 有团购
        if (grouponRules != null) {
            order.setGrouponPrice(grouponPrice);    //  团购价格
        } else {
            order.setGrouponPrice(new BigDecimal(0));    //  团购价格
        }

        // 添加订单表项
        orderService.add(order);
        orderId = order.getId();


        // 添加订单商品表项
        for (LitemallCart cartGoods : checkedGoodsList) {
            // 订单商品
            LitemallOrderGoods orderGoods = new LitemallOrderGoods();
            orderGoods.setOrderId(order.getId());
            orderGoods.setGoodsId(cartGoods.getGoodsId());
            orderGoods.setGoodsSn(cartGoods.getGoodsSn());
            orderGoods.setProductId(cartGoods.getProductId());
            orderGoods.setGoodsName(cartGoods.getGoodsName());
            orderGoods.setPicUrl(cartGoods.getPicUrl());
            orderGoods.setPrice(cartGoods.getPrice());
            orderGoods.setNumber(cartGoods.getNumber());
            orderGoods.setSpecifications(cartGoods.getSpecifications());
            orderGoods.setAddTime(LocalDateTime.now());

            orderGoodsService.add(orderGoods);
        }

        // 删除购物车里面的商品信息
        if (cartId.equals(0)) {
            cartService.clearGoods(userId);
        } else {
            cartService.deleteById(cartId);
        }

        // 商品货品数量减少
        for (LitemallCart checkGoods : checkedGoodsList) {
            Integer productId = checkGoods.getProductId();
            LitemallGoodsProduct product = productService.findById(productId);

            int remainNumber = product.getNumber() - checkGoods.getNumber();
            if (remainNumber < 0) {
                throw new RuntimeException("下单的商品货品数量大于库存量");
            }
            if (productService.reduceStock(productId, checkGoods.getNumber()) == 0) {
                throw new RuntimeException("商品货品库存减少失败");
            }
        }

        // 如果使用了优惠券，设置优惠券使用状态
        if (couponId != 0 && couponId != -1) {
            LitemallCouponUser couponUser = couponUserService.findById(userCouponId);
            couponUser.setStatus(CouponUserConstant.STATUS_USED);
            couponUser.setUsedTime(LocalDateTime.now());
            couponUser.setOrderId(orderId);
            couponUserService.update(couponUser);
        }

        //如果是团购项目，添加团购信息
        if (grouponRulesId != null && grouponRulesId > 0) {
            LitemallGroupon groupon = new LitemallGroupon();
            groupon.setOrderId(orderId);
            groupon.setStatus(GrouponConstant.STATUS_NONE);
            groupon.setUserId(userId);
            groupon.setRulesId(grouponRulesId);

            //参与者
            if (grouponLinkId != null && grouponLinkId > 0) {
                //参与的团购记录
                LitemallGroupon baseGroupon = grouponService.queryById(grouponLinkId);
                groupon.setCreatorUserId(baseGroupon.getCreatorUserId());
                groupon.setGrouponId(grouponLinkId);
                groupon.setShareUrl(baseGroupon.getShareUrl());
                grouponService.createGroupon(groupon);
            } else {
                groupon.setCreatorUserId(userId);
                groupon.setCreatorUserTime(LocalDateTime.now());
                groupon.setGrouponId(0);
                grouponService.createGroupon(groupon);
                grouponLinkId = groupon.getId();
            }
        }

        // NOTE: 建议开发者从业务场景核实下面代码，防止用户利用业务BUG使订单跳过支付环节。
        // 如果订单实际支付费用是0，则直接跳过支付变成待发货状态
        boolean payed = false;
        if (order.getActualPrice().equals(new BigDecimal("0.00"))) {
            payed = true;

            LitemallOrder o = new LitemallOrder();
            o.setId(orderId);
            o.setOrderStatus(OrderUtil.STATUS_PAY);
            orderService.updateSelective(o);

            //  支付成功，有团购信息，更新团购信息
            LitemallGroupon groupon = grouponService.queryByOrderId(order.getId());
            if (groupon != null) {
                grouponRules = grouponRulesService.findById(groupon.getRulesId());

                //仅当发起者才创建分享图片
                if (groupon.getGrouponId() == 0) {
                    String url = qCodeService.createGrouponShareImage(grouponRules.getGoodsName(), grouponRules.getPicUrl(), groupon);
                    groupon.setShareUrl(url);
                }
                groupon.setStatus(GrouponConstant.STATUS_ON);
                if (grouponService.updateById(groupon) == 0) {
                    throw new RuntimeException("更新数据已失效");
                }


                List<LitemallGroupon> grouponList = grouponService.queryJoinRecord(groupon.getGrouponId());
                if (groupon.getGrouponId() != 0 && (grouponList.size() >= grouponRules.getDiscountMember() - 1)) {
                    for (LitemallGroupon grouponActivity : grouponList) {
                        grouponActivity.setStatus(GrouponConstant.STATUS_SUCCEED);
                        grouponService.updateById(grouponActivity);
                    }

                    LitemallGroupon grouponSource = grouponService.queryById(groupon.getGrouponId());
                    grouponSource.setStatus(GrouponConstant.STATUS_SUCCEED);
                    grouponService.updateById(grouponSource);
                }
            }

            //TODO 发送邮件和短信通知，这里采用异步发送
            // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
            notifyService.notifyMail("新订单通知", order.toString());
            // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
            notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{order.getOrderSn().substring(8, 14)});
        } else {
            // 订单支付超期任务
            taskService.addTask(new OrderUnpaidTask(orderId));
        }

        Map<String, Object> data = new HashMap<>();
        data.put("orderId", orderId);
        data.put("payed", payed);
        if (grouponRulesId != null && grouponRulesId > 0) {
            data.put("grouponLinkId", grouponLinkId);
        } else {
            data.put("grouponLinkId", 0);
        }
        return ResponseUtil.ok(data);
    }


    /**
     * 取消订单
     * <p>
     * 1. 检测当前订单是否能够取消；
     * 2. 设置订单取消状态；
     * 3. 商品货品库存恢复；
     * 4. 返还优惠券；
     *
     * @param userId 用户ID
     * @param body   订单信息，{ orderId：xxx }
     * @return 取消订单操作结果
     */
    @Transactional
    public Object cancel(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgumentValue();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        LocalDateTime preUpdateTime = order.getUpdateTime();

        // 检测是否能够取消
        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isCancel()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能取消");
        }

        // 设置订单已取消状态
        order.setOrderStatus(OrderUtil.STATUS_CANCEL);
        order.setEndTime(LocalDateTime.now());
        if (orderService.updateWithOptimisticLocker(order) == 0) {
            throw new RuntimeException("更新数据已失效");
        }

        // 商品货品数量增加
        List<LitemallOrderGoods> orderGoodsList = orderGoodsService.queryByOid(orderId);
        for (LitemallOrderGoods orderGoods : orderGoodsList) {
            Integer productId = orderGoods.getProductId();
            Short number = orderGoods.getNumber();
            if (productService.addStock(productId, number) == 0) {
                throw new RuntimeException("商品货品库存增加失败");
            }
        }

        // 返还优惠券
        releaseCoupon(orderId);

        return ResponseUtil.ok();
    }

    /**
     * 付款订单的预支付会话标识
     * <p>
     * 1. 检测当前订单是否能够付款
     * 2. 微信商户平台返回支付订单ID
     * 3. 设置订单付款状态
     *
     * @param userId 用户ID
     * @param body   订单信息，{ orderId：xxx }
     * @return 支付订单ID
     */
    @Transactional
    public Object prepay(Integer userId, String body, HttpServletRequest request) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }
        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgumentValue();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        // 检测是否能够取消
        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isPay()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能支付");
        }

        LitemallUser user = userService.findById(userId);
        String openid = user.getWeixinOpenid();

        if (openid == null) {
            return ResponseUtil.fail(AUTH_OPENID_UNACCESS, "订单不能支付");
        }

        WxPayMpOrderResult result = null;
        try {
            WxPayUnifiedOrderRequest orderRequest = new WxPayUnifiedOrderRequest();
            orderRequest.setOutTradeNo(order.getOrderSn());
            orderRequest.setOpenid(openid);
            orderRequest.setBody("订单：" + order.getOrderSn());
            // 元转成分
            int fee = 0;
            BigDecimal actualPrice = order.getActualPrice();
            fee = actualPrice.multiply(new BigDecimal(100)).intValue();
            orderRequest.setTotalFee(fee);
            orderRequest.setSpbillCreateIp(IpUtil.getIpAddr(request));

            result = wxPayService.createOrder(orderRequest);
            logger.info("result:" + result.toString());
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseUtil.fail(ORDER_PAY_FAIL, "订单不能支付");
        }

        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return ResponseUtil.updatedDateExpired();
        }
        return ResponseUtil.ok(result);
    }

    /**
     * 微信H5支付
     *
     * @param userId
     * @param body
     * @param request
     * @return
     */
    @Transactional
    public Object h5pay(Integer userId, String body, HttpServletRequest request) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgumentValue();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        // 检测是否能够取消
        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isPay()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能支付");
        }

        WxPayMwebOrderResult result = null;
        try {
            WxPayUnifiedOrderRequest orderRequest = new WxPayUnifiedOrderRequest();
            orderRequest.setOutTradeNo(order.getOrderSn());
            orderRequest.setTradeType("MWEB");
            orderRequest.setBody("订单：" + order.getOrderSn());
            // 元转成分
            int fee = 0;
            BigDecimal actualPrice = order.getActualPrice();
            fee = actualPrice.multiply(new BigDecimal(100)).intValue();
            orderRequest.setTotalFee(fee);
            orderRequest.setSpbillCreateIp(IpUtil.getIpAddr(request));

            result = wxPayService.createOrder(orderRequest);

        } catch (Exception e) {
            e.printStackTrace();
        }

        return ResponseUtil.ok(result);
    }

    /**
     * 微信付款成功或失败回调接口
     * <p>
     * 1. 检测当前订单是否是付款状态;
     * 2. 设置订单付款成功状态相关信息;
     * 3. 响应微信商户平台.
     *
     * @param request  请求内容
     * @param response 响应内容
     * @return 操作结果
     */
    @Transactional
    public Object payNotify(HttpServletRequest request, HttpServletResponse response) {
        String xmlResult = null;
        try {
            xmlResult = IOUtils.toString(request.getInputStream(), request.getCharacterEncoding());
        } catch (IOException e) {
            e.printStackTrace();
            return WxPayNotifyResponse.fail(e.getMessage());
        }

        WxPayOrderNotifyResult result = null;
        try {
            result = wxPayService.parseOrderNotifyResult(xmlResult);

            if (!WxPayConstants.ResultCode.SUCCESS.equals(result.getResultCode())) {
                logger.error(xmlResult);
                throw new WxPayException("微信通知支付失败！");
            }
            if (!WxPayConstants.ResultCode.SUCCESS.equals(result.getReturnCode())) {
                logger.error(xmlResult);
                throw new WxPayException("微信通知支付失败！");
            }
        } catch (WxPayException e) {
            e.printStackTrace();
            return WxPayNotifyResponse.fail(e.getMessage());
        }

        logger.info("处理腾讯支付平台的订单支付");
        logger.info(result);

        String orderSn = result.getOutTradeNo();
        String payId = result.getTransactionId();

        // 分转化成元
        String totalFee = BaseWxPayResult.fenToYuan(result.getTotalFee());
        LitemallOrder order = orderService.findBySn(orderSn);
        if (order == null) {
            return WxPayNotifyResponse.fail("订单不存在 sn=" + orderSn);
        }

        // 检查这个订单是否已经处理过
        if (OrderUtil.hasPayed(order)) {
            return WxPayNotifyResponse.success("订单已经处理成功!");
        }

        // 检查支付订单金额
        if (!totalFee.equals(order.getActualPrice().toString())) {
            return WxPayNotifyResponse.fail(order.getOrderSn() + " : 支付金额不符合 totalFee=" + totalFee);
        }

        order.setPayId(payId);
        order.setPayTime(LocalDateTime.now());
        order.setOrderStatus(OrderUtil.STATUS_PAY);
        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return WxPayNotifyResponse.fail("更新数据已失效");
        }

        //  支付成功，有团购信息，更新团购信息
        LitemallGroupon groupon = grouponService.queryByOrderId(order.getId());
        if (groupon != null) {
            LitemallGrouponRules grouponRules = grouponRulesService.findById(groupon.getRulesId());

            //仅当发起者才创建分享图片
            if (groupon.getGrouponId() == 0) {
                String url = qCodeService.createGrouponShareImage(grouponRules.getGoodsName(), grouponRules.getPicUrl(), groupon);
                groupon.setShareUrl(url);
            }
            groupon.setStatus(GrouponConstant.STATUS_ON);
            if (grouponService.updateById(groupon) == 0) {
                return WxPayNotifyResponse.fail("更新数据已失效");
            }


            List<LitemallGroupon> grouponList = grouponService.queryJoinRecord(groupon.getGrouponId());
            if (groupon.getGrouponId() != 0 && (grouponList.size() >= grouponRules.getDiscountMember() - 1)) {
                for (LitemallGroupon grouponActivity : grouponList) {
                    grouponActivity.setStatus(GrouponConstant.STATUS_SUCCEED);
                    grouponService.updateById(grouponActivity);
                }

                LitemallGroupon grouponSource = grouponService.queryById(groupon.getGrouponId());
                grouponSource.setStatus(GrouponConstant.STATUS_SUCCEED);
                grouponService.updateById(grouponSource);
            }
        }

        //TODO 发送邮件和短信通知，这里采用异步发送
        // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
        notifyService.notifyMail("新订单通知", order.toString());
        // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
        notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{orderSn.substring(8, 14)});

        // 取消订单超时未支付任务
        taskService.removeTask(new OrderUnpaidTask(order.getId()));

        return WxPayNotifyResponse.success("处理成功!");
    }

    /**
     * 梨膏糖
     * 微信付款成功或失败回调接口
     * <p>
     * 1. 检测当前订单是否是付款状态;
     * 2. 设置订单付款成功状态相关信息;
     * 3. 响应微信商户平台.
     *
     * @param request  请求内容
     * @param response 响应内容
     * @return 操作结果
     */
    @Transactional
    public Object payNotifyLigaotang(HttpServletRequest request, HttpServletResponse response) {
        String xmlResult = null;
        try {
            xmlResult = IOUtils.toString(request.getInputStream(), request.getCharacterEncoding());
        } catch (IOException e) {
            e.printStackTrace();
            return WxPayNotifyResponse.fail(e.getMessage());
        }

        WxPayOrderNotifyResult result = null;
        try {
            result = wxPayService.parseOrderNotifyResult(xmlResult);

            if (!WxPayConstants.ResultCode.SUCCESS.equals(result.getResultCode())) {
                logger.error(xmlResult);
                throw new WxPayException("微信通知支付失败！");
            }
            if (!WxPayConstants.ResultCode.SUCCESS.equals(result.getReturnCode())) {
                logger.error(xmlResult);
                throw new WxPayException("微信通知支付失败！");
            }
        } catch (WxPayException e) {
            e.printStackTrace();
            return WxPayNotifyResponse.fail(e.getMessage());
        }

        logger.info("处理腾讯支付平台的订单支付");
        logger.error("====处理腾讯支付平台的订单支付返回的数据========");
        logger.info(result);

        String orderSn = result.getOutTradeNo();
        String payId = result.getTransactionId();

        // 分转化成元
        String totalFee = BaseWxPayResult.fenToYuan(result.getTotalFee());
        LitemallOrder order = orderService.findBySn(orderSn);
        if (order == null) {
            return WxPayNotifyResponse.fail("订单不存在 sn=" + orderSn);
        }

        // 检查这个订单是否已经处理过
        if (OrderUtil.hasPayed(order)) {
            return WxPayNotifyResponse.success("订单已经处理成功!");
        }

        // 检查支付订单金额
        if (!totalFee.equals(order.getActualPrice().toString())) {
            return WxPayNotifyResponse.fail(order.getOrderSn() + " : 支付金额不符合 totalFee=" + totalFee);
        }

        order.setPayId(payId);
        LocalDateTime time2 = new Date().toInstant().atZone(ZoneId.of("+8")).toLocalDateTime();
        order.setPayTime(time2);
        order.setOrderStatus(OrderUtil.STATUS_PAY);
        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return WxPayNotifyResponse.fail("更新数据已失效");
        }

        //  支付成功，有团购信息，更新团购信息
        LitemallGroupon groupon = grouponService.queryByOrderId(order.getId());
// 删除---------------------------
//        if (groupon != null) {
//            LitemallGrouponRules grouponRules = grouponRulesService.findById(groupon.getRulesId());
//
//            //仅当发起者才创建分享图片
//            if (groupon.getGrouponId() == 0) {
//                String url = qCodeService.createGrouponShareImage(grouponRules.getGoodsName(), grouponRules.getPicUrl(), groupon);
//                groupon.setShareUrl(url);
//            }
//            groupon.setStatus(GrouponConstant.STATUS_ON);
//            if (grouponService.updateById(groupon) == 0) {
//                return WxPayNotifyResponse.fail("更新数据已失效");
//            }
//
//
//            List<LitemallGroupon> grouponList = grouponService.queryJoinRecord(groupon.getGrouponId());
//            if (groupon.getGrouponId() != 0 && (grouponList.size() >= grouponRules.getDiscountMember() - 1)) {
//                for (LitemallGroupon grouponActivity : grouponList) {
//                    grouponActivity.setStatus(GrouponConstant.STATUS_SUCCEED);
//                    grouponService.updateById(grouponActivity);
//                }
//
//                LitemallGroupon grouponSource = grouponService.queryById(groupon.getGrouponId());
//                grouponSource.setStatus(GrouponConstant.STATUS_SUCCEED);
//                grouponService.updateById(grouponSource);
//            }
//        }

        //TODO 发送邮件和短信通知，这里采用异步发送
        // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
// 删除---------------------------
        notifyService.notifyMail("新订单通知", order.toString());
        // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
        notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{orderSn.substring(8, 14)});

        // 2022.10.23 梨膏糖积分奖励计算payxiaofeiquan
        //updateUserIntegral(order.getUserId(), order.getIntegralPrice().doubleValue());

        //orderService.updateSelective(order); // 发现支付回调函数没有保存订单信息，导致微信支付后订单状态未改变

        // 取消订单超时未支付任务
        taskService.removeTask(new OrderUnpaidTask(order.getId()));

        return WxPayNotifyResponse.success("处理成功!");
    }

    /**
     * 订单申请退款
     * <p>
     * 1. 检测当前订单是否能够退款；
     * 2. 设置订单申请退款状态。
     *
     * @param userId 用户ID
     * @param body   订单信息，{ orderId：xxx }
     * @return 订单退款操作结果
     */
    public Object refund(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgument();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isRefund()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能取消");
        }

        // 设置订单申请退款状态
        order.setOrderStatus(OrderUtil.STATUS_REFUND);
        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return ResponseUtil.updatedDateExpired();
        }

        //TODO 发送邮件和短信通知，这里采用异步发送
        // 有用户申请退款，邮件通知运营人员
        notifyService.notifyMail("退款申请", order.toString());

        return ResponseUtil.ok();
    }

    /**
     * 确认收货
     * <p>
     * 1. 检测当前订单是否能够确认收货；
     * 2. 设置订单确认收货状态。
     *
     * @param userId 用户ID
     * @param body   订单信息，{ orderId：xxx }
     * @return 订单操作结果
     */
    public Object confirm(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgument();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isConfirm()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能确认收货");
        }

        Short comments = orderGoodsService.getComments(orderId);
        order.setComments(comments);

        order.setOrderStatus(OrderUtil.STATUS_CONFIRM);
        order.setConfirmTime(LocalDateTime.now());
        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return ResponseUtil.updatedDateExpired();
        }


        // =====================给代理分配奖励---梨膏糖
        //当前订单需要支付的费用
        double  price= Double.parseDouble(order.getOrderPrice().toString());
        Double integral = price;
        updateUserIntegral(userId,integral,order);
        // ==========================给代理分配奖励---梨膏糖

        return ResponseUtil.ok();
    }

    /**
     * 删除订单
     * <p>
     * 1. 检测当前订单是否可以删除；
     * 2. 删除订单。
     *
     * @param userId 用户ID
     * @param body   订单信息，{ orderId：xxx }
     * @return 订单操作结果
     */
    public Object delete(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        Integer orderId = JacksonUtil.parseInteger(body, "orderId");
        if (orderId == null) {
            return ResponseUtil.badArgument();
        }

        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgument();
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.badArgumentValue();
        }

        OrderHandleOption handleOption = OrderUtil.build(order);
        if (!handleOption.isDelete()) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "订单不能删除");
        }

        // 订单order_status没有字段用于标识删除
        // 而是存在专门的delete字段表示是否删除
        orderService.deleteById(orderId);
        // 售后也同时删除
        aftersaleService.deleteByOrderId(userId, orderId);

        return ResponseUtil.ok();
    }

    /**
     * 待评价订单商品信息
     *
     * @param userId 用户ID
     * @param ogid   订单商品ID
     * @return 待评价订单商品信息
     */
    public Object goods(Integer userId, Integer ogid) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }
        LitemallOrderGoods orderGoods = orderGoodsService.findById(ogid);

        if (orderGoods != null) {
            Integer orderId = orderGoods.getOrderId();
            LitemallOrder order = orderService.findById(orderId);
            if (!order.getUserId().equals(userId)) {
                return ResponseUtil.badArgument();
            }
        }
        return ResponseUtil.ok(orderGoods);
    }

    /**
     * 评价订单商品
     * <p>
     * 确认商品收货或者系统自动确认商品收货后7天内可以评价，过期不能评价。
     *
     * @param userId 用户ID
     * @param body   订单信息，{ "orderGoodsId"：xxx,"content":xxx,"star":x,"hasPicture":ture/false,"picUrls":[] }
     * @return 订单操作结果
     */
    public Object comment(Integer userId, String body) {
        if (userId == null) {
            return ResponseUtil.unlogin();
        }

        Integer orderGoodsId = JacksonUtil.parseInteger(body, "orderGoodsId");
        if (orderGoodsId == null) {
            return ResponseUtil.badArgument();
        }
        LitemallOrderGoods orderGoods = orderGoodsService.findById(orderGoodsId);
        if (orderGoods == null) {
            return ResponseUtil.badArgumentValue();
        }
        Integer orderId = orderGoods.getOrderId();
        LitemallOrder order = orderService.findById(userId, orderId);
        if (order == null) {
            return ResponseUtil.badArgumentValue();
        }
        if (!OrderUtil.isConfirmStatus(order) && !OrderUtil.isAutoConfirmStatus(order)) {
            return ResponseUtil.fail(ORDER_INVALID_OPERATION, "当前商品不能评价");
        }
        if (!order.getUserId().equals(userId)) {
            return ResponseUtil.fail(ORDER_INVALID, "当前商品不属于用户");
        }
        Integer commentId = orderGoods.getComment();
        if (commentId == -1) {
            return ResponseUtil.fail(ORDER_COMMENT_EXPIRED, "当前商品评价时间已经过期");
        }
        if (commentId != 0) {
            return ResponseUtil.fail(ORDER_COMMENTED, "订单商品已评价");
        }

        String content = JacksonUtil.parseString(body, "content");
        Integer star = JacksonUtil.parseInteger(body, "star");
        if (star == null || star < 0 || star > 5) {
            return ResponseUtil.badArgumentValue();
        }
        Boolean hasPicture = JacksonUtil.parseBoolean(body, "hasPicture");
        List<String> picUrls = JacksonUtil.parseStringList(body, "picUrls");
        if (hasPicture == null || !hasPicture) {
            picUrls = new ArrayList<>(0);
        }

        // 1. 创建评价
        LitemallComment comment = new LitemallComment();
        comment.setUserId(userId);
        comment.setType((byte) 0);
        comment.setValueId(orderGoods.getGoodsId());
        comment.setStar(star.shortValue());
        comment.setContent(content);
        comment.setHasPicture(hasPicture);
        comment.setPicUrls(picUrls.toArray(new String[]{}));
        commentService.save(comment);

        // 2. 更新订单商品的评价列表
        orderGoods.setComment(comment.getId());
        orderGoodsService.updateById(orderGoods);

        // 3. 更新订单中未评价的订单商品可评价数量
        Short commentCount = order.getComments();
        if (commentCount > 0) {
            commentCount--;
        }
        order.setComments(commentCount);
        orderService.updateWithOptimisticLocker(order);

        return ResponseUtil.ok();
    }

    /**
     * 取消订单/退款返还优惠券
     * <br/>
     *
     * @param orderId
     * @return void
     * @author Tyson
     * @date 2020/6/8/0008 1:41
     */
    public void releaseCoupon(Integer orderId) {
        List<LitemallCouponUser> couponUsers = couponUserService.findByOid(orderId);
        for (LitemallCouponUser couponUser : couponUsers) {
            // 优惠券状态设置为可使用
            couponUser.setStatus(CouponUserConstant.STATUS_USABLE);
            couponUser.setUpdateTime(LocalDateTime.now());
            couponUserService.update(couponUser);
        }
    }

    @Transactional
    public Object process(AlipayNotifyParam param) {


        //从支付宝返回的信息中获取订单编号
        String outTradeNo = param.getOutTradeNo();


        LitemallOrder order = orderService.findBySn(outTradeNo);


        if (order == null) {
            logger.info("########查询订单为空！########");
            return null;
        }
/*******   为了防止出现并发 ，使用lock锁住 下面的内容         ***************/
        try {
            lock.lock();


            int orderid = order.getId();
            int userId = order.getUserId();

            // 货品价格
            //   List<LitemallCart> checkedGoodsList = cartService.queryByUidAndChecked(userId);

            List<LitemallOrderGoods> litemallOrderGoods = orderGoodsService.selectByorderid(order.getId());

            /** 转 fsp  sun   ***********************************/

//String  userIds=""+userId;

//当前用户信息
            LitemallUser my = userService.findById(userId);


/***** 个人业绩  *************************************************************************************************************/
            LitemallUser isyeji = new LitemallUser();
            isyeji.setId(my.getId());
            isyeji.setMypay(Double.parseDouble(order.getActualPrice().toString()));
            userService.updateUserMoney(isyeji);


/***** **********************************************************************************************************/

            /**
             * 如果是 消费券的支付类型 ，先判断消费券 够不够
             * **/
/*if(1==paytype){

    //消费券  - 实际支付金额
    if(my.getXiaofeiquan() - Double.parseDouble(  actualPrice.toString())   > 0){


    }else {

        return ResponseUtil.fail(503, "优惠券不足！当前优惠券剩余："+my.getXiaofeiquan() +",实际支付金额为"+ Double.parseDouble(  actualPrice.toString()) );

    }

}*/


/***** 订单添加成功 ，把订单的数据写到 FSP   **************************************************************************************************************/
            double fsp = 0.00;
            double fspt = 0.00;

            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {

                int spid = cartGoods.getGoodsId();
                //当前商品备受
                int beishu = litemallGoodsService.getbeishu(spid);
                if (beishu != 1) {
                    // fsp =fsp+ 商品价格 x 商品数量      fspt =fspt+ 商品价格 x 商品数量 x 商品倍数 -1

                    fspt = fspt + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()) * (beishu - 1));
                }
                fsp = fsp + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()));
            }
            LitemallUser litemallUser = new LitemallUser();
            litemallUser.setId(userId);
            litemallUser.setFSP(fsp);
            litemallUser.setFSPT(fspt);
            userService.updateUserMoney(litemallUser);
/***  录入日志   **/
            litemallMoneyLogService.insertMoney(0, fsp, "用户购买商品，获得FSP", userId, "FSP", 4, my.getFSP() + fsp, orderid);
            if (fspt != 0) {
                litemallMoneyLogService.insertMoney(0, fspt, "用户购买商品，获得FST", userId, "FST", 4, my.getFSPT() + fspt, orderid);
            }
/*****/

/*****   ***************************************************************************************************************************** *****/




//用户链

            String[] userlianarr = my.getUserlian().split(",");
/** 我的等级 **/
            int myleave = my.getUserLevel();



/***** 管理奖    **************************************************************************************************************/
            if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());

                for (int i = 0; i < userlianarr.length; i++) {
// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
                    if (userlianarr.length - i == 1) {
                        break;
                    }
                    /***出现同级次数*/
                    int cha = 0;
                    //当前用户
                    int nowuserid = Integer.parseInt(userlianarr[i]);
                    LitemallUser litemallUsersum = userService.findById(nowuserid);

                    double nowsun = litemallUsersum.getSUN();
                    double nowfsp = litemallUsersum.getFSP();
                    double nowfst = litemallUsersum.getFSPT();
//当前用户等级 从最大等级开始
                    int leave = litemallUsersum.getUserLevel();
                    if (leave == 0) {
                        continue;
                    }

/** 差级, 0 代表平级 ,负数代表 没有团队奖励金***/
                    int cleave = leave - myleave;


/***  最大链 - 本人 不等于 -  则代表 是可以发管理奖的 **/
                    //         System.out.println(String.format("当前购买用户等级 %s  , for的当前等级 %s ，当前用户%s ",myleave,leave,litemallUsersum.getUsername()));
                    if (cleave >= 0) {
                        /**
                         * 是否 进行 fst 转 fsp   1 转  ，0  不转 ,isglj   =当前用户 的管理奖
                         */
                        int fstzfsp = 0;
                        double  isglj=0;
                        //     System.out.println("当前等级"+leave +",当前用户是"+litemallUsersum.getUsername());
                        /** 判断当前 最大链 还有下一位  假设 3人   012    如果是第二位 i=1 结果等于 2 进入else*/
                        if (userlianarr.length - i > 2) {
                            //         System.out.println(String.format("当前的人 的 下一位 不是本人"));
                            /**** 5555  22  0  0    ****/
                            // 当前用户的下一用户  当前是 第一次 是5
                            int nextuserid = Integer.parseInt(userlianarr[i + 1]);
                            LitemallUser litemallUsersumnext = userService.findById(nextuserid);
// 当前用户的 下一用户等级   是 第二个 5
                            int nextleave = litemallUsersumnext.getUserLevel();
                            int gljbs = leave - nextleave > 0 ? leave - nextleave : 1;
                            /**** 5555  22  0  0    ****/
                            /***  出现当前和下一个都是5  55  然后需要判断下一个 是不是还是 5  ***/
                            if (nextleave == leave) {
                                //    System.out.println(String.format("出现同级"));
                                /*** 假设9个人  8人获得奖金   5555  22   00  本人 , 从当前最大人数开始便利 ***/
                                // 下下一用户   两个5  以后 ，第三个用户
                                int nnextuserid = Integer.parseInt(userlianarr[i + 2]);
                                LitemallUser litemallUsersumnextn = userService.findById(nnextuserid);
                                //下下一用户等级
                                int nnextleave = litemallUsersumnextn.getUserLevel();
                                /***  如果 第三个是  5    ，那么代表 当前的 第一个5  是没有奖励金的 ，直接退出循环 ***/
                                if (nextleave == nnextleave) {
                                    continue;
                                } else {
                                    cha = 1;
                                    double sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.1);
                                    isglj=sunglj;
                                    if (nowfsp == 0 && nowfst == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);
                                        litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        continue;
                                    }
                                    if (nowfst-sunglj>=0){
                                        /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
                                        userService.MoneyProup(nowuserid,sunglj,2);
                                        userService.MoneyProdown(nowuserid,sunglj,1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                        /*****/
                                        //当前有多余的fst  可以进入fst转 fsp
                                        if (nowfst - nowsun > 0) {
                                            fstzfsp = 1;
                                        }

                                    }else {
                                        //不够扣  , 如果有 fstp  ,先扣到0
                                        if (nowfst > 0) {
                                            /**   //减FSPT  **/
                                            userService.MoneyProdown(nowuserid, nowfst, 1);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                            /**   //加SUN **/
                                            userService.MoneyProup(nowuserid, nowfst, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                            /*****/
                                            //总数 -扣掉的FSPT
                                            sunglj = sunglj - nowfst;
                                            if (nowfsp == 0) {
                                                /**
                                                 ** 记录完全没有钱的 亏损
                                                 */
                                                userService.MoneyProup(nowuserid, sunglj, 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                continue;
                                            }
                                            //判断 fsp 是否 够扣
                                            if (nowfsp - sunglj < 0) {
                                                /**
                                                 * 记录亏损
                                                 */
                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                //不够扣，有多少 扣多少
                                                sunglj = nowfsp;
                                            }
                                            /**  //减FSP  */
                                            userService.MoneyProdown(nowuserid, sunglj, 0);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                            /****   //加SUN */
                                            userService.MoneyProup(nowuserid, sunglj, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                            /*****/
                                        } else {
                                            //不够扣  , 且没有fst
                                            if (nowfsp == 0) {
                                                /**
                                                 ** 记录完全没有钱的 亏损
                                                 */
                                                userService.MoneyProup(nowuserid, sunglj, 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                continue;
                                            }
                                            //判断 fsp 是否 够扣
                                            if (nowfsp - sunglj < 0) {
                                                /**
                                                 * 记录亏损
                                                 */
                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                //不够扣，有多少 扣多少
                                                sunglj = nowfsp;
                                            }
                                            /**  //减FSP  */
                                            userService.MoneyProdown(nowuserid, sunglj, 0);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                            /****   //加SUN */
                                            userService.MoneyProup(nowuserid, sunglj, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                        }
                                    }
                                }
                            } else {
                                /** 给奖励金 sun  例如  5   5  4    当前是第二个5  或者    543  的第一个 5 **/
                                double sunglj =0.00;
                                if (cha == 1) {
                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.9);
                                    isglj=sunglj;
                                } else {
                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)));
                                    isglj=sunglj;
                                }
                                if (nowfsp == 0 && nowfst == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(nowuserid, sunglj, 5);
                                    litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                    continue;
                                }
                                if (nowfst-sunglj>=0){
                                    /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
                                    userService.MoneyProup(nowuserid,sunglj,2);
                                    userService.MoneyProdown(nowuserid,sunglj,1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                    /*****/
                                    //当前有多余的fst  可以进入fst转 fsp
                                    if (nowfst - nowsun > 0) {
                                        fstzfsp = 1;
                                    }

                                }else {
                                    //不够扣  , 如果有 fstp  ,先扣到0
                                    if (nowfst > 0) {
                                        /**   //减FSPT  **/
                                        userService.MoneyProdown(nowuserid, nowfst, 1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                        /**   //加SUN **/
                                        userService.MoneyProup(nowuserid, nowfst, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                        /*****/
                                        //总数 -扣掉的FSPT
                                        sunglj = sunglj - nowfst;

                                        if (nowfsp == 0) {
                                            /**
                                             ** 记录完全没有钱的 亏损
                                             */
                                            userService.MoneyProup(nowuserid, sunglj, 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            continue;
                                        }
                                        //判断 fsp 是否 够扣
                                        if (nowfsp - sunglj < 0) {
                                            /**
                                             * 记录亏损
                                             */
                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            //不够扣，有多少 扣多少
                                            sunglj = nowfsp;
                                        }
                                        /**  //减FSP  */
                                        userService.MoneyProdown(nowuserid, sunglj, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                        //加SUN */
                                        userService.MoneyProup(nowuserid, sunglj, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                        /*****/

                                    } else {
                                        //不够扣  , 且没有fst
                                        if (nowfsp == 0) {
                                            /**
                                             ** 记录完全没有钱的 亏损
                                             */
                                            userService.MoneyProup(nowuserid, sunglj, 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            continue;
                                        }
                                        //判断 fsp 是否 够扣
                                        if (nowfsp - sunglj < 0) {
                                            /**
                                             * 记录亏损
                                             */
                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            //不够扣，有多少 扣多少
                                            sunglj = nowfsp;
                                        }
                                        /**  //减FSP  */
                                        userService.MoneyProdown(nowuserid, sunglj, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                        /****   //加SUN */
                                        userService.MoneyProup(nowuserid, sunglj, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                    }
                                }

                            }
                        } else {
                            double sunglj =0.00;
                            if (cha == 1) {
                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)) * 0.9);
                                isglj=sunglj;
                            } else {
                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)));
                                isglj=sunglj;
                            }
                            if (nowfsp == 0 && nowfst == 0) {
                                /**
                                 ** 记录完全没有钱的 亏损
                                 */
                                userService.MoneyProup(nowuserid, sunglj, 5);
                                litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                continue;
                            }
                            if (nowfst-sunglj>=0){
                                userService.MoneyProup(nowuserid,sunglj,2);
                                userService.MoneyProdown(nowuserid,sunglj,1);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                /*****/
                                //当前有多余的fst  可以进入fst转 fsp
                                if (nowfst - nowsun > 0) {
                                    fstzfsp = 1;
                                }

                            }else {
                                //不够扣  , 如果有 fstp  ,先扣到0
                                if (nowfst > 0) {

                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, nowfst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                    /**   //加SUN **/
                                    userService.MoneyProup(nowuserid, nowfst, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                    /*****/
                                    //总数 -扣掉的FSPT
                                    sunglj = sunglj - nowfst;
                                    if (nowfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);

                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);

                                        continue;
                                    }
                                    //判断 fsp 是否 够扣
                                    if (nowfsp - sunglj < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        sunglj = nowfsp;
                                    }
                                    /**  //减FSP  */
                                    userService.MoneyProdown(nowuserid, sunglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                    /****   //加SUN */
                                    userService.MoneyProup(nowuserid, sunglj, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                    /*****/

                                } else {
                                    //不够扣  , 且没有fst
                                    if (nowfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        continue;
                                    }
                                    //判断 fsp 是否 够扣
                                    if (nowfsp - sunglj < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        sunglj = nowfsp;
                                    }
                                    /**  //减FSP  */
                                    userService.MoneyProdown(nowuserid, sunglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                    /****   //加SUN */
                                    userService.MoneyProup(nowuserid, sunglj, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                }
                            }


                        }


                        /**
                         * 开始将 fst 转 fsp
                         */
                        if (fstzfsp == 1) {
                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
                            /**
                             * 从新查，并且要大于零
                             */
                            if (getfsp.getFSPT() > 0) {
                                double twofst = getfsp.getFSPT();
                                double twofsp = getfsp.getFSP();

                                if (twofst - isglj >= 0) {
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, isglj, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(isglj, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, twofst - isglj, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(nowuserid, isglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, isglj, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofsp + isglj, orderid);
                                    /*****/

                                } else {
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - isglj), 0, "团队获得管理奖，产生FSP亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, twofst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(twofst, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(nowuserid, twofst, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, twofst, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofst + twofsp, orderid);
                                    /*****/
                                }

                            }
                        }






                    }

                }

            }

            /*************************************************************************************************************************************************
             * 直推 ，间推
             */

            if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());

                for (int i = 0; i < userlianarr.length; i++) {
// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
                    if (userlianarr.length - i == 1) {
                        break;
                    }
                    //当前用户
                    int nowuserid = Integer.parseInt(userlianarr[i]);
                    LitemallUser litemallUsersum = userService.findById(nowuserid);

                    double nowsun = litemallUsersum.getSUN();

                    //倍率
                    double nowbeilv = 0.00;
//当前用户等级 从最大等级开始
                    int leave = litemallUsersum.getUserLevel();
                    if (userlianarr.length - i <= 3) {
                        //计算当前倍率
                        //直推
                        /**
                         * 是否 进行 fst 转 fsp   1 转  ，0  不转
                         */
                        int fstzfsp = 0;
                        int zmt = 0;
                        if (userlianarr.length - i == 2) {
                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("直推", leave)) * 0.01;
                            zmt = 1;
                        } else {
                            //间接推
                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("间推", leave)) * 0.01;
                            zmt = 2;
                        }
                        //当前用户获得的佣金 SUM
                        double mysum = OrderPrices * nowbeilv;
                        int myid = litemallUsersum.getId();
                        double myfsp = litemallUsersum.getFSP();
                        double myfspt = litemallUsersum.getFSPT();
//当前用户没有钱   跳下一用户
                        if (litemallUsersum.getFSP() == 0 && litemallUsersum.getFSPT() == 0) {
                            /**
                             ** 记录完全没有钱的 亏损
                             */
                            userService.MoneyProup(myid, mysum, 5);

                            litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人完全没有FST与FSP产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                            continue;
                        }
                        //优先完成 sun的转换
                        //先扣 FSPT   ，如果FSPT够 扣
                        if (myfspt - mysum >= 0) {

                            /**   //减FSPT  **/
                            userService.MoneyProdown(myid, mysum, 1);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,，失去FST", myid, "FST", zmt, myfspt - mysum, orderid);
                            /*****/
                            /**   //加SUN **/
                            userService.MoneyProup(myid, mysum, 2);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
                            /*****/
//当前有多余的fst  可以进入fst转 fsp
                            if (myfspt - mysum > 0) {
                                fstzfsp = 1;
                            }

                        } else {
                            //不够扣  , 如果有 fstp  ,先扣到0
                            if (myfspt > 0) {

                                /**   //减FSPT  **/
                                userService.MoneyProdown(myid, myfspt, 1);

                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(myfspt, 0, "推荐人获得奖励,失去FST", myid, "FST", zmt, 0.00, orderid);
                                /*****/

                                /**   //加SUN **/
                                userService.MoneyProup(myid, myfspt, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, myfspt, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + myfspt, orderid);
                                /*****/
                                //总数 -扣掉的FSPT
                                mysum = mysum - myfspt;

                                if (myfsp == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(myid, mysum, 5);

                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                                    continue;
                                }
                                //判断 fsp 是否 够扣
                                if (myfsp - mysum < 0) {
                                    /**
                                     * 记录亏损
                                     */
                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
                                    //不够扣，有多少 扣多少
                                    mysum = myfsp;
                                }
                                /**  //减FSP  */
                                userService.MoneyProdown(myid, mysum, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
                                /*****/
/****   //加SUN */
                                userService.MoneyProup(myid, mysum, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,，FSP转SUN", myid, "SUN", zmt, nowsun + myfspt + mysum, orderid);
                                /*****/

                            } else {
                                //不够扣  , 且没有fst
                                if (myfsp == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(myid, mysum, 5);

                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                                    continue;
                                }
                                //判断 fsp 是否 够扣
                                if (myfsp - mysum < 0) {
                                    /**
                                     * 记录亏损
                                     */
                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
                                    //不够扣，有多少 扣多少
                                    mysum = myfsp;
                                }
                                /**  //减FSP  */
                                userService.MoneyProdown(myid, mysum, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
                                /*****/
/****   //加SUN */
                                userService.MoneyProup(myid, mysum, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FSP转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
                                /*****/

                            }

                        }

                        /**
                         * 开始将 fst 转 fsp
                         */
                        if (fstzfsp == 1) {
                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
                            /**
                             * 从新查，并且要大于零
                             */
                            if (getfsp.getFSPT() > 0) {
                                double twofst = getfsp.getFSPT();
                                double twofsp = getfsp.getFSP();

                                if (twofst - mysum >= 0) {
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(myid, mysum, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, twofst - mysum, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(myid, mysum, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofsp + mysum, orderid);
                                    /*****/

                                } else {
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "推荐人获得奖励，产生FSP亏损", myid, "亏损", zmt, 0.00, orderid);
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(myid, twofst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(twofst, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, 0.00, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(myid, twofst, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, twofst, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofst + twofsp, orderid);
                                    /*****/
                                }

                            }
                        }


                    }
                }

            }
/*****   ***************************************************************************************************************************** *****/


/*****  获得 品牌方奖励 **  7.14改*************************************************************************************************************************** *****/


/*****  获得 品牌方奖励 **  7.27改*************************************************************************************************************************** *****/


            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {
                //被购买商品获得的奖励
                double mysum = 0.00;
                double fsts = 0.00;
                int spid = cartGoods.getGoodsId();
                //当前品牌方信息
                LitemallUser ppfuser = userService.selectBySPId(spid);
                /**
                 * 是否 进行 fst 转 fsp   1 转  ，0  不转
                 */
                int fstzfsp = 0;
                if (ppfuser != null) {
                    fsts = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBybasetype("商家奖", 0)) * 0.01));
                    LitemallUser setppf = new LitemallUser();
                    setppf.setId(ppfuser.getId());
                    setppf.setFSPT(mysum);
                    userService.updateUserMoney(setppf);

                    //   int myid = ppfuser.getId();
                    //  double myfsp = ppfuser.getFSP();
                    //   double myfspt = ppfuser.getFSPT();
                    //   double nowsun = ppfuser.getSUN();
                    /*****************************/

                    /**   //fst **/
                    userService.MoneyProup(ppfuser.getId(), fsts, 1);
                    /***  录入日志   **/
                    litemallMoneyLogService.insertMoney(0, fsts, "商家获得购买商品奖励FST", ppfuser.getId(), "FST", 3,  ppfuser.getFSPT() + fsts, orderid);
                    /*****/

                    String mylian = ppfuser.getUserlian();
                    //    System.out.println(mylian+"我的用户链是");
                    String[] lians = mylian.split(",");
                    if ( lians.length >= 2) {
                        //    System.out.println("存在二级链");
                        for (int i = 0;i< lians.length ; i++) {
                            if (i == lians.length - 3) {
                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ003")) *0.01));
                            } else if (i == lians.length - 2) {
                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ002")) *0.01));
                            } else {
                                continue;
                            }
                            LitemallUser  sjtj=userService.findById(Integer.parseInt(lians[i]));
                            //       System.out.println(sjtj.getNickname());
                            int myid = sjtj.getId();
                            double myfsp = sjtj.getFSP();
                            double myfspt = sjtj.getFSPT();
                            double nowsun = sjtj.getSUN();

                            //先扣 FSPT   ，如果FSPT够 扣
                            if (myfspt - mysum >= 0) {

                                /**   //减FSPT  **/
                                userService.MoneyProdown(myid, mysum, 1);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, myfspt - mysum, orderid);
                                /*****/
                                /**   //加SUN **/
                                userService.MoneyProup(myid, mysum, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + mysum, orderid);
                                /*****/
                                //当前有多余的fst  可以进入fst转 fsp
                                if (myfspt - mysum > 0) {
                                    fstzfsp = 1;
                                }
                            } else {
                                //不够扣  , 如果有 fstp  ,先扣到0
                                if (myfspt > 0) {

                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(myid, myfspt, 1);

                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(myfspt, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
                                    /*****/

                                    /**   //加SUN **/
                                    userService.MoneyProup(myid, myfspt, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, myfspt, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + myfspt, orderid);
                                    /*****/

                                    //总数 -扣掉的FSPT
                                    mysum = mysum - myfspt;
                                    if (myfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(myid, mysum, 5);

                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);

                                        continue;
                                    }

                                    //判断 fsp 是否 够扣
                                    if (myfsp - mysum < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        mysum = myfsp;
                                    }
//扣 ftp
                                    /**  //减FSP  */
                                    userService.MoneyProdown(myid, mysum, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
                                    /*****/
/****   //加SUN */
                                    userService.MoneyProup(myid, mysum, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
                                    /*****/

                                } else {
                                    //不够扣  , 且没有fst
                                    if (myfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(myid, mysum, 5);

                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);

                                        continue;
                                    }
                                    //判断 fsp 是否 够扣
                                    if (myfsp - mysum < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        mysum = myfsp;
                                    }
                                    /**  //减FSP  */
                                    userService.MoneyProdown(myid, mysum, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
                                    /*****/
/****   //加SUN */
                                    userService.MoneyProup(myid, mysum, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
                                    /*****/

                                }

                            }

                            /**
                             * 开始将 fst 转 fsp
                             */
                            if (fstzfsp == 1) {
                                LitemallUser getfsp = userService.findById(ppfuser.getId());
                                /**
                                 * 从新查，并且要大于零
                                 */
                                if (getfsp.getFSPT() > 0) {
                                    double twofst = getfsp.getFSPT();
                                    double twofsp = getfsp.getFSP();

                                    if (twofst - mysum >= 0) {
                                        /**   //减FSPT  **/
                                        userService.MoneyProdown(myid, mysum, 1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, twofst - mysum, orderid);
                                        /*****/
                                        /**   //加FSP **/
                                        userService.MoneyProup(myid, mysum, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofsp + mysum, orderid);
                                        /*****/

                                    } else {
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "商家推荐人获得购买商品奖励，产生FSP亏损", myid, "亏损", 3, 0.00, orderid);
                                        /**   //减FSPT  **/
                                        userService.MoneyProdown(myid, twofst, 1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(twofst, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
                                        /*****/
                                        /**   //加FSP **/
                                        userService.MoneyProup(myid, twofst, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, twofst, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofst + twofsp, orderid);
                                        /*****/
                                    }

                                }
                            }

                            /**/
                        }}

                }


            }
            /*****   ***************************************************************************************************************************** *****/



        } catch (Exception e) {

        } finally {
            //不管异常，释放锁 防止线程卡死
            lock.unlock();
        }

/*****   ***************************************************************************************************************************** *****/



        //设置支付宝订单编号
        order.setPayId(param.getTradeNo());

        order.setPayTime(LocalDateTime.now());

        order.setOrderStatus(OrderUtil.STATUS_PAY);

        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return WxPayNotifyResponse.fail("更新数据已失效");
        }

        //  支付成功，有团购信息，更新团购信息
        LitemallGroupon groupon = grouponService.queryByOrderId(order.getId());
        if (groupon != null) {
            LitemallGrouponRules grouponRules = grouponRulesService.findById(groupon.getRulesId());

            //仅当发起者才创建分享图片
            if (groupon.getGrouponId() == 0) {
                String url = qCodeService.createGrouponShareImage(grouponRules.getGoodsName(), grouponRules.getPicUrl(), groupon);
                groupon.setShareUrl(url);
            }
            groupon.setStatus(GrouponConstant.STATUS_ON);
            if (grouponService.updateById(groupon) == 0) {
                return WxPayNotifyResponse.fail("更新数据已失效");
            }


            List<LitemallGroupon> grouponList = grouponService.queryJoinRecord(groupon.getGrouponId());
            if (groupon.getGrouponId() != 0 && (grouponList.size() >= grouponRules.getDiscountMember() - 1)) {
                for (LitemallGroupon grouponActivity : grouponList) {
                    grouponActivity.setStatus(GrouponConstant.STATUS_SUCCEED);
                    grouponService.updateById(grouponActivity);
                }

                LitemallGroupon grouponSource = grouponService.queryById(groupon.getGrouponId());
                grouponSource.setStatus(GrouponConstant.STATUS_SUCCEED);
                grouponService.updateById(grouponSource);
            }
        }

        //TODO 发送邮件和短信通知，这里采用异步发送
        // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
        // notifyService.notifyMail("新订单通知", order.toString());
        // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
        // notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{outTradeNo.substring(8, 14)});

        // 取消订单超时未支付任务
        taskService.removeTask(new OrderUnpaidTask(order.getId()));

        return WxPayNotifyResponse.success("处理成功!");

    }

    @Transactional
    public Object processLigaotang(AlipayNotifyParam param) {


        //从支付宝返回的信息中获取订单编号
        String outTradeNo = param.getOutTradeNo();


        LitemallOrder order = orderService.findBySn(outTradeNo);


        if (order == null) {
            logger.info("########查询订单为空！########");
            return null;
        }
/*******   为了防止出现并发 ，使用lock锁住 下面的内容         ***************/
        try {
            lock.lock();


            int orderid = order.getId();
            int userId = order.getUserId();

            // 货品价格
            //   List<LitemallCart> checkedGoodsList = cartService.queryByUidAndChecked(userId);

            List<LitemallOrderGoods> litemallOrderGoods = orderGoodsService.selectByorderid(order.getId());

            /** 转 fsp  sun   ***********************************/

//String  userIds=""+userId;

//当前用户信息
            LitemallUser my = userService.findById(userId);


/***** 个人业绩 (删除) *************************************************************************************************************/
//            LitemallUser isyeji = new LitemallUser();
//            isyeji.setId(my.getId());
//            isyeji.setMypay(Double.parseDouble(order.getActualPrice().toString()));
//            userService.updateUserMoney(isyeji);


/***** **********************************************************************************************************/

            /**
             * 如果是 消费券的支付类型 ，先判断消费券 够不够
             * **/
/*if(1==paytype){

    //消费券  - 实际支付金额
    if(my.getXiaofeiquan() - Double.parseDouble(  actualPrice.toString())   > 0){


    }else {

        return ResponseUtil.fail(503, "优惠券不足！当前优惠券剩余："+my.getXiaofeiquan() +",实际支付金额为"+ Double.parseDouble(  actualPrice.toString()) );

    }

}*/


/***** 订单添加成功 ，把订单的数据写到 FSP   **************************************************************************************************************/
            /**（删除）----------------
            double fsp = 0.00;
            double fspt = 0.00;

            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {

                int spid = cartGoods.getGoodsId();
                //当前商品备受
                int beishu = litemallGoodsService.getbeishu(spid);
                if (beishu != 1) {
                    // fsp =fsp+ 商品价格 x 商品数量      fspt =fspt+ 商品价格 x 商品数量 x 商品倍数 -1

                    fspt = fspt + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()) * (beishu - 1));
                }
                fsp = fsp + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()));
            }
            LitemallUser litemallUser = new LitemallUser();
            litemallUser.setId(userId);
            litemallUser.setFSP(fsp);
            litemallUser.setFSPT(fspt);
            userService.updateUserMoney(litemallUser);
/***  录入日志   **/
//            litemallMoneyLogService.insertMoney(0, fsp, "用户购买商品，获得FSP", userId, "FSP", 4, my.getFSP() + fsp, orderid);
//            if (fspt != 0) {
//                litemallMoneyLogService.insertMoney(0, fspt, "用户购买商品，获得FST", userId, "FST", 4, my.getFSPT() + fspt, orderid);
//            }
           // （删除）----------------
/*****/

/*****   ***************************************************************************************************************************** *****/




//用户链

            String[] userlianarr = my.getUserlian().split(",");
/** 我的等级 **/
            int myleave = my.getUserLevel();


// 删除
/***** 管理奖    **************************************************************************************************************/
//
//             if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
//                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
//                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());
//
//                for (int i = 0; i < userlianarr.length; i++) {
//// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
//                    if (userlianarr.length - i == 1) {
//                        break;
//                    }
//                    /***出现同级次数*/
//                    int cha = 0;
//                    //当前用户
//                    int nowuserid = Integer.parseInt(userlianarr[i]);
//                    LitemallUser litemallUsersum = userService.findById(nowuserid);
//
//                    double nowsun = litemallUsersum.getSUN();
//                    double nowfsp = litemallUsersum.getFSP();
//                    double nowfst = litemallUsersum.getFSPT();
////当前用户等级 从最大等级开始
//                    int leave = litemallUsersum.getUserLevel();
//                    if (leave == 0) {
//                        continue;
//                    }
//
///** 差级, 0 代表平级 ,负数代表 没有团队奖励金***/
//                    int cleave = leave - myleave;
//
//
///***  最大链 - 本人 不等于 -  则代表 是可以发管理奖的 **/
//                    //         System.out.println(String.format("当前购买用户等级 %s  , for的当前等级 %s ，当前用户%s ",myleave,leave,litemallUsersum.getUsername()));
//                    if (cleave >= 0) {
//                        /**
//                         * 是否 进行 fst 转 fsp   1 转  ，0  不转 ,isglj   =当前用户 的管理奖
//                         */
//                        int fstzfsp = 0;
//                        double  isglj=0;
//                        //     System.out.println("当前等级"+leave +",当前用户是"+litemallUsersum.getUsername());
//                        /** 判断当前 最大链 还有下一位  假设 3人   012    如果是第二位 i=1 结果等于 2 进入else*/
//                        if (userlianarr.length - i > 2) {
//                            //         System.out.println(String.format("当前的人 的 下一位 不是本人"));
//                            /**** 5555  22  0  0    ****/
//                            // 当前用户的下一用户  当前是 第一次 是5
//                            int nextuserid = Integer.parseInt(userlianarr[i + 1]);
//                            LitemallUser litemallUsersumnext = userService.findById(nextuserid);
//// 当前用户的 下一用户等级   是 第二个 5
//                            int nextleave = litemallUsersumnext.getUserLevel();
//                            int gljbs = leave - nextleave > 0 ? leave - nextleave : 1;
//                            /**** 5555  22  0  0    ****/
//                            /***  出现当前和下一个都是5  55  然后需要判断下一个 是不是还是 5  ***/
//                            if (nextleave == leave) {
//                                //    System.out.println(String.format("出现同级"));
//                                /*** 假设9个人  8人获得奖金   5555  22   00  本人 , 从当前最大人数开始便利 ***/
//                                // 下下一用户   两个5  以后 ，第三个用户
//                                int nnextuserid = Integer.parseInt(userlianarr[i + 2]);
//                                LitemallUser litemallUsersumnextn = userService.findById(nnextuserid);
//                                //下下一用户等级
//                                int nnextleave = litemallUsersumnextn.getUserLevel();
//                                /***  如果 第三个是  5    ，那么代表 当前的 第一个5  是没有奖励金的 ，直接退出循环 ***/
//                                if (nextleave == nnextleave) {
//                                    continue;
//                                } else {
//                                    cha = 1;
//                                    double sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.1);
//                                    isglj=sunglj;
//                                    if (nowfsp == 0 && nowfst == 0) {
//                                        /**
//                                         ** 记录完全没有钱的 亏损
//                                         */
//                                        userService.MoneyProup(nowuserid, sunglj, 5);
//                                        litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                        continue;
//                                    }
//                                    if (nowfst-sunglj>=0){
//                                        /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
//                                        userService.MoneyProup(nowuserid,sunglj,2);
//                                        userService.MoneyProdown(nowuserid,sunglj,1);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
//                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
//                                        /*****/
//                                        //当前有多余的fst  可以进入fst转 fsp
//                                        if (nowfst - nowsun > 0) {
//                                            fstzfsp = 1;
//                                        }
//
//                                    }else {
//                                        //不够扣  , 如果有 fstp  ,先扣到0
//                                        if (nowfst > 0) {
//                                            /**   //减FSPT  **/
//                                            userService.MoneyProdown(nowuserid, nowfst, 1);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
//                                            /**   //加SUN **/
//                                            userService.MoneyProup(nowuserid, nowfst, 2);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
//                                            /*****/
//                                            //总数 -扣掉的FSPT
//                                            sunglj = sunglj - nowfst;
//                                            if (nowfsp == 0) {
//                                                /**
//                                                 ** 记录完全没有钱的 亏损
//                                                 */
//                                                userService.MoneyProup(nowuserid, sunglj, 5);
//                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                                continue;
//                                            }
//                                            //判断 fsp 是否 够扣
//                                            if (nowfsp - sunglj < 0) {
//                                                /**
//                                                 * 记录亏损
//                                                 */
//                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                                //不够扣，有多少 扣多少
//                                                sunglj = nowfsp;
//                                            }
//                                            /**  //减FSP  */
//                                            userService.MoneyProdown(nowuserid, sunglj, 0);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                            /****   //加SUN */
//                                            userService.MoneyProup(nowuserid, sunglj, 2);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
//                                            /*****/
//                                        } else {
//                                            //不够扣  , 且没有fst
//                                            if (nowfsp == 0) {
//                                                /**
//                                                 ** 记录完全没有钱的 亏损
//                                                 */
//                                                userService.MoneyProup(nowuserid, sunglj, 5);
//                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                                continue;
//                                            }
//                                            //判断 fsp 是否 够扣
//                                            if (nowfsp - sunglj < 0) {
//                                                /**
//                                                 * 记录亏损
//                                                 */
//                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                                //不够扣，有多少 扣多少
//                                                sunglj = nowfsp;
//                                            }
//                                            /**  //减FSP  */
//                                            userService.MoneyProdown(nowuserid, sunglj, 0);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                            /****   //加SUN */
//                                            userService.MoneyProup(nowuserid, sunglj, 2);
//                                            /***  录入日志   **/
//                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
//                                        }
//                                    }
//                                }
//                            } else {
//                                /** 给奖励金 sun  例如  5   5  4    当前是第二个5  或者    543  的第一个 5 **/
//                                double sunglj =0.00;
//                                if (cha == 1) {
//                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.9);
//                                    isglj=sunglj;
//                                } else {
//                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)));
//                                    isglj=sunglj;
//                                }
//                                if (nowfsp == 0 && nowfst == 0) {
//                                    /**
//                                     ** 记录完全没有钱的 亏损
//                                     */
//                                    userService.MoneyProup(nowuserid, sunglj, 5);
//                                    litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                    continue;
//                                }
//                                if (nowfst-sunglj>=0){
//                                    /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
//                                    userService.MoneyProup(nowuserid,sunglj,2);
//                                    userService.MoneyProdown(nowuserid,sunglj,1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
//                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
//                                    /*****/
//                                    //当前有多余的fst  可以进入fst转 fsp
//                                    if (nowfst - nowsun > 0) {
//                                        fstzfsp = 1;
//                                    }
//
//                                }else {
//                                    //不够扣  , 如果有 fstp  ,先扣到0
//                                    if (nowfst > 0) {
//                                        /**   //减FSPT  **/
//                                        userService.MoneyProdown(nowuserid, nowfst, 1);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
//                                        /**   //加SUN **/
//                                        userService.MoneyProup(nowuserid, nowfst, 2);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
//                                        /*****/
//                                        //总数 -扣掉的FSPT
//                                        sunglj = sunglj - nowfst;
//
//                                        if (nowfsp == 0) {
//                                            /**
//                                             ** 记录完全没有钱的 亏损
//                                             */
//                                            userService.MoneyProup(nowuserid, sunglj, 5);
//                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                            continue;
//                                        }
//                                        //判断 fsp 是否 够扣
//                                        if (nowfsp - sunglj < 0) {
//                                            /**
//                                             * 记录亏损
//                                             */
//                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                            //不够扣，有多少 扣多少
//                                            sunglj = nowfsp;
//                                        }
//                                        /**  //减FSP  */
//                                        userService.MoneyProdown(nowuserid, sunglj, 0);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                        //加SUN */
//                                        userService.MoneyProup(nowuserid, sunglj, 2);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
//                                        /*****/
//
//                                    } else {
//                                        //不够扣  , 且没有fst
//                                        if (nowfsp == 0) {
//                                            /**
//                                             ** 记录完全没有钱的 亏损
//                                             */
//                                            userService.MoneyProup(nowuserid, sunglj, 5);
//                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                            continue;
//                                        }
//                                        //判断 fsp 是否 够扣
//                                        if (nowfsp - sunglj < 0) {
//                                            /**
//                                             * 记录亏损
//                                             */
//                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                            //不够扣，有多少 扣多少
//                                            sunglj = nowfsp;
//                                        }
//                                        /**  //减FSP  */
//                                        userService.MoneyProdown(nowuserid, sunglj, 0);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                        /****   //加SUN */
//                                        userService.MoneyProup(nowuserid, sunglj, 2);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
//                                    }
//                                }
//
//                            }
//                        } else {
//                            double sunglj =0.00;
//                            if (cha == 1) {
//                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)) * 0.9);
//                                isglj=sunglj;
//                            } else {
//                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)));
//                                isglj=sunglj;
//                            }
//                            if (nowfsp == 0 && nowfst == 0) {
//                                /**
//                                 ** 记录完全没有钱的 亏损
//                                 */
//                                userService.MoneyProup(nowuserid, sunglj, 5);
//                                litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                continue;
//                            }
//                            if (nowfst-sunglj>=0){
//                                userService.MoneyProup(nowuserid,sunglj,2);
//                                userService.MoneyProdown(nowuserid,sunglj,1);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
//                                litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
//                                /*****/
//                                //当前有多余的fst  可以进入fst转 fsp
//                                if (nowfst - nowsun > 0) {
//                                    fstzfsp = 1;
//                                }
//
//                            }else {
//                                //不够扣  , 如果有 fstp  ,先扣到0
//                                if (nowfst > 0) {
//
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(nowuserid, nowfst, 1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
//                                    /**   //加SUN **/
//                                    userService.MoneyProup(nowuserid, nowfst, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
//                                    /*****/
//                                    //总数 -扣掉的FSPT
//                                    sunglj = sunglj - nowfst;
//                                    if (nowfsp == 0) {
//                                        /**
//                                         ** 记录完全没有钱的 亏损
//                                         */
//                                        userService.MoneyProup(nowuserid, sunglj, 5);
//
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//
//                                        continue;
//                                    }
//                                    //判断 fsp 是否 够扣
//                                    if (nowfsp - sunglj < 0) {
//                                        /**
//                                         * 记录亏损
//                                         */
//                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                        //不够扣，有多少 扣多少
//                                        sunglj = nowfsp;
//                                    }
//                                    /**  //减FSP  */
//                                    userService.MoneyProdown(nowuserid, sunglj, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                    /****   //加SUN */
//                                    userService.MoneyProup(nowuserid, sunglj, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
//                                    /*****/
//
//                                } else {
//                                    //不够扣  , 且没有fst
//                                    if (nowfsp == 0) {
//                                        /**
//                                         ** 记录完全没有钱的 亏损
//                                         */
//                                        userService.MoneyProup(nowuserid, sunglj, 5);
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                        continue;
//                                    }
//                                    //判断 fsp 是否 够扣
//                                    if (nowfsp - sunglj < 0) {
//                                        /**
//                                         * 记录亏损
//                                         */
//                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                        //不够扣，有多少 扣多少
//                                        sunglj = nowfsp;
//                                    }
//                                    /**  //减FSP  */
//                                    userService.MoneyProdown(nowuserid, sunglj, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
//                                    /****   //加SUN */
//                                    userService.MoneyProup(nowuserid, sunglj, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
//                                }
//                            }
//
//
//                        }
//
//
//                        /**
//                         * 开始将 fst 转 fsp
//                         */
//                        if (fstzfsp == 1) {
//                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
//                            /**
//                             * 从新查，并且要大于零
//                             */
//                            if (getfsp.getFSPT() > 0) {
//                                double twofst = getfsp.getFSPT();
//                                double twofsp = getfsp.getFSP();
//
//                                if (twofst - isglj >= 0) {
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(nowuserid, isglj, 1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(isglj, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, twofst - isglj, orderid);
//                                    /*****/
//                                    /**   //加FSP **/
//                                    userService.MoneyProup(nowuserid, isglj, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, isglj, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofsp + isglj, orderid);
//                                    /*****/
//
//                                } else {
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - isglj), 0, "团队获得管理奖，产生FSP亏损", nowuserid, "亏损", 5, 0.00, orderid);
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(nowuserid, twofst, 1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(twofst, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, 0.00, orderid);
//                                    /*****/
//                                    /**   //加FSP **/
//                                    userService.MoneyProup(nowuserid, twofst, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, twofst, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofst + twofsp, orderid);
//                                    /*****/
//                                }
//
//                            }
//                        }
//
//
//
//
//
//
//                    }
//
//                }
//
//            }

            /*************************************************************************************************************************************************
             * 直推 ，间推
             */
// 删除
//            if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
//                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
//                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());
//
//                for (int i = 0; i < userlianarr.length; i++) {
//// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
//                    if (userlianarr.length - i == 1) {
//                        break;
//                    }
//                    //当前用户
//                    int nowuserid = Integer.parseInt(userlianarr[i]);
//                    LitemallUser litemallUsersum = userService.findById(nowuserid);
//
//                    double nowsun = litemallUsersum.getSUN();
//
//                    //倍率
//                    double nowbeilv = 0.00;
////当前用户等级 从最大等级开始
//                    int leave = litemallUsersum.getUserLevel();
//                    if (userlianarr.length - i <= 3) {
//                        //计算当前倍率
//                        //直推
//                        /**
//                         * 是否 进行 fst 转 fsp   1 转  ，0  不转
//                         */
//                        int fstzfsp = 0;
//                        int zmt = 0;
//                        if (userlianarr.length - i == 2) {
//                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("直推", leave)) * 0.01;
//                            zmt = 1;
//                        } else {
//                            //间接推
//                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("间推", leave)) * 0.01;
//                            zmt = 2;
//                        }
//                        //当前用户获得的佣金 SUM
//                        double mysum = OrderPrices * nowbeilv;
//                        int myid = litemallUsersum.getId();
//                        double myfsp = litemallUsersum.getFSP();
//                        double myfspt = litemallUsersum.getFSPT();
////当前用户没有钱   跳下一用户
//                        if (litemallUsersum.getFSP() == 0 && litemallUsersum.getFSPT() == 0) {
//                            /**
//                             ** 记录完全没有钱的 亏损
//                             */
//                            userService.MoneyProup(myid, mysum, 5);
//
//                            litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人完全没有FST与FSP产生的亏损", myid, "亏损", zmt, 0.00, orderid);
//
//                            continue;
//                        }
//                        //优先完成 sun的转换
//                        //先扣 FSPT   ，如果FSPT够 扣
//                        if (myfspt - mysum >= 0) {
//
//                            /**   //减FSPT  **/
//                            userService.MoneyProdown(myid, mysum, 1);
//                            /***  录入日志   **/
//                            litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,，失去FST", myid, "FST", zmt, myfspt - mysum, orderid);
//                            /*****/
//                            /**   //加SUN **/
//                            userService.MoneyProup(myid, mysum, 2);
//                            /***  录入日志   **/
//                            litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
//                            /*****/
////当前有多余的fst  可以进入fst转 fsp
//                            if (myfspt - mysum > 0) {
//                                fstzfsp = 1;
//                            }
//
//                        } else {
//                            //不够扣  , 如果有 fstp  ,先扣到0
//                            if (myfspt > 0) {
//
//                                /**   //减FSPT  **/
//                                userService.MoneyProdown(myid, myfspt, 1);
//
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(myfspt, 0, "推荐人获得奖励,失去FST", myid, "FST", zmt, 0.00, orderid);
//                                /*****/
//
//                                /**   //加SUN **/
//                                userService.MoneyProup(myid, myfspt, 2);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(0, myfspt, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + myfspt, orderid);
//                                /*****/
//                                //总数 -扣掉的FSPT
//                                mysum = mysum - myfspt;
//
//                                if (myfsp == 0) {
//                                    /**
//                                     ** 记录完全没有钱的 亏损
//                                     */
//                                    userService.MoneyProup(myid, mysum, 5);
//
//                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
//
//                                    continue;
//                                }
//                                //判断 fsp 是否 够扣
//                                if (myfsp - mysum < 0) {
//                                    /**
//                                     * 记录亏损
//                                     */
//                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
//                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
//                                    //不够扣，有多少 扣多少
//                                    mysum = myfsp;
//                                }
//                                /**  //减FSP  */
//                                userService.MoneyProdown(myid, mysum, 0);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
//                                /*****/
///****   //加SUN */
//                                userService.MoneyProup(myid, mysum, 2);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,，FSP转SUN", myid, "SUN", zmt, nowsun + myfspt + mysum, orderid);
//                                /*****/
//
//                            } else {
//                                //不够扣  , 且没有fst
//                                if (myfsp == 0) {
//                                    /**
//                                     ** 记录完全没有钱的 亏损
//                                     */
//                                    userService.MoneyProup(myid, mysum, 5);
//
//                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
//
//                                    continue;
//                                }
//                                //判断 fsp 是否 够扣
//                                if (myfsp - mysum < 0) {
//                                    /**
//                                     * 记录亏损
//                                     */
//                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
//                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
//                                    //不够扣，有多少 扣多少
//                                    mysum = myfsp;
//                                }
//                                /**  //减FSP  */
//                                userService.MoneyProdown(myid, mysum, 0);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
//                                /*****/
///****   //加SUN */
//                                userService.MoneyProup(myid, mysum, 2);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FSP转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
//                                /*****/
//
//                            }
//
//                        }
//
//                        /**
//                         * 开始将 fst 转 fsp
//                         */
//                        if (fstzfsp == 1) {
//                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
//                            /**
//                             * 从新查，并且要大于零
//                             */
//                            if (getfsp.getFSPT() > 0) {
//                                double twofst = getfsp.getFSPT();
//                                double twofsp = getfsp.getFSP();
//
//                                if (twofst - mysum >= 0) {
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(myid, mysum, 1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, twofst - mysum, orderid);
//                                    /*****/
//                                    /**   //加FSP **/
//                                    userService.MoneyProup(myid, mysum, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofsp + mysum, orderid);
//                                    /*****/
//
//                                } else {
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "推荐人获得奖励，产生FSP亏损", myid, "亏损", zmt, 0.00, orderid);
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(myid, twofst, 1);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(twofst, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, 0.00, orderid);
//                                    /*****/
//                                    /**   //加FSP **/
//                                    userService.MoneyProup(myid, twofst, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, twofst, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofst + twofsp, orderid);
//                                    /*****/
//                                }
//
//                            }
//                        }
//
//
//                    }
//                }
//
//            }
/*****   ***************************************************************************************************************************** *****/


/*****  获得 品牌方奖励 **  7.14改*************************************************************************************************************************** *****/


/*****  获得 品牌方奖励 **  7.27改*************************************************************************************************************************** *****/

// 删除
//            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {
//                //被购买商品获得的奖励
//                double mysum = 0.00;
//                double fsts = 0.00;
//                int spid = cartGoods.getGoodsId();
//                //当前品牌方信息
//                LitemallUser ppfuser = userService.selectBySPId(spid);
//                /**
//                 * 是否 进行 fst 转 fsp   1 转  ，0  不转
//                 */
//                int fstzfsp = 0;
//                if (ppfuser != null) {
//                    fsts = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBybasetype("商家奖", 0)) * 0.01));
//                    LitemallUser setppf = new LitemallUser();
//                    setppf.setId(ppfuser.getId());
//                    setppf.setFSPT(mysum);
//                    userService.updateUserMoney(setppf);
//
//                    //   int myid = ppfuser.getId();
//                    //  double myfsp = ppfuser.getFSP();
//                    //   double myfspt = ppfuser.getFSPT();
//                    //   double nowsun = ppfuser.getSUN();
//                    /*****************************/
//
//                    /**   //fst **/
//                    userService.MoneyProup(ppfuser.getId(), fsts, 1);
//                    /***  录入日志   **/
//                    litemallMoneyLogService.insertMoney(0, fsts, "商家获得购买商品奖励FST", ppfuser.getId(), "FST", 3,  ppfuser.getFSPT() + fsts, orderid);
//                    /*****/
//
//                    String mylian = ppfuser.getUserlian();
//                    //    System.out.println(mylian+"我的用户链是");
//                    String[] lians = mylian.split(",");
//                    if ( lians.length >= 2) {
//                        //    System.out.println("存在二级链");
//                        for (int i = 0;i< lians.length ; i++) {
//                            if (i == lians.length - 3) {
//                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ003")) *0.01));
//                            } else if (i == lians.length - 2) {
//                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ002")) *0.01));
//                            } else {
//                                continue;
//                            }
//                            LitemallUser  sjtj=userService.findById(Integer.parseInt(lians[i]));
//                            //       System.out.println(sjtj.getNickname());
//                            int myid = sjtj.getId();
//                            double myfsp = sjtj.getFSP();
//                            double myfspt = sjtj.getFSPT();
//                            double nowsun = sjtj.getSUN();
//
//                            //先扣 FSPT   ，如果FSPT够 扣
//                            if (myfspt - mysum >= 0) {
//
//                                /**   //减FSPT  **/
//                                userService.MoneyProdown(myid, mysum, 1);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, myfspt - mysum, orderid);
//                                /*****/
//                                /**   //加SUN **/
//                                userService.MoneyProup(myid, mysum, 2);
//                                /***  录入日志   **/
//                                litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + mysum, orderid);
//                                /*****/
//                                //当前有多余的fst  可以进入fst转 fsp
//                                if (myfspt - mysum > 0) {
//                                    fstzfsp = 1;
//                                }
//                            } else {
//                                //不够扣  , 如果有 fstp  ,先扣到0
//                                if (myfspt > 0) {
//
//                                    /**   //减FSPT  **/
//                                    userService.MoneyProdown(myid, myfspt, 1);
//
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(myfspt, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
//                                    /*****/
//
//                                    /**   //加SUN **/
//                                    userService.MoneyProup(myid, myfspt, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, myfspt, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + myfspt, orderid);
//                                    /*****/
//
//                                    //总数 -扣掉的FSPT
//                                    mysum = mysum - myfspt;
//                                    if (myfsp == 0) {
//                                        /**
//                                         ** 记录完全没有钱的 亏损
//                                         */
//                                        userService.MoneyProup(myid, mysum, 5);
//
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
//
//                                        continue;
//                                    }
//
//                                    //判断 fsp 是否 够扣
//                                    if (myfsp - mysum < 0) {
//                                        /**
//                                         * 记录亏损
//                                         */
//                                        userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
//                                        //不够扣，有多少 扣多少
//                                        mysum = myfsp;
//                                    }
////扣 ftp
//                                    /**  //减FSP  */
//                                    userService.MoneyProdown(myid, mysum, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
//                                    /*****/
///****   //加SUN */
//                                    userService.MoneyProup(myid, mysum, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
//                                    /*****/
//
//                                } else {
//                                    //不够扣  , 且没有fst
//                                    if (myfsp == 0) {
//                                        /**
//                                         ** 记录完全没有钱的 亏损
//                                         */
//                                        userService.MoneyProup(myid, mysum, 5);
//
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
//
//                                        continue;
//                                    }
//                                    //判断 fsp 是否 够扣
//                                    if (myfsp - mysum < 0) {
//                                        /**
//                                         * 记录亏损
//                                         */
//                                        userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
//                                        litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
//                                        //不够扣，有多少 扣多少
//                                        mysum = myfsp;
//                                    }
//                                    /**  //减FSP  */
//                                    userService.MoneyProdown(myid, mysum, 0);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
//                                    /*****/
///****   //加SUN */
//                                    userService.MoneyProup(myid, mysum, 2);
//                                    /***  录入日志   **/
//                                    litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
//                                    /*****/
//
//                                }
//
//                            }
//
//                            /**
//                             * 开始将 fst 转 fsp
//                             */
//                            if (fstzfsp == 1) {
//                                LitemallUser getfsp = userService.findById(ppfuser.getId());
//                                /**
//                                 * 从新查，并且要大于零
//                                 */
//                                if (getfsp.getFSPT() > 0) {
//                                    double twofst = getfsp.getFSPT();
//                                    double twofsp = getfsp.getFSP();
//
//                                    if (twofst - mysum >= 0) {
//                                        /**   //减FSPT  **/
//                                        userService.MoneyProdown(myid, mysum, 1);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, twofst - mysum, orderid);
//                                        /*****/
//                                        /**   //加FSP **/
//                                        userService.MoneyProup(myid, mysum, 0);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofsp + mysum, orderid);
//                                        /*****/
//
//                                    } else {
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "商家推荐人获得购买商品奖励，产生FSP亏损", myid, "亏损", 3, 0.00, orderid);
//                                        /**   //减FSPT  **/
//                                        userService.MoneyProdown(myid, twofst, 1);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(twofst, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
//                                        /*****/
//                                        /**   //加FSP **/
//                                        userService.MoneyProup(myid, twofst, 0);
//                                        /***  录入日志   **/
//                                        litemallMoneyLogService.insertMoney(0, twofst, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofst + twofsp, orderid);
//                                        /*****/
//                                    }
//
//                                }
//                            }
//
//                            /**/
//                        }}
//
//                }
//
//
//            }
            /*****   ***************************************************************************************************************************** *****/



        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //不管异常，释放锁 防止线程卡死
            lock.unlock();
        }

/*****   ***************************************************************************************************************************** *****/


        // 2022.10.23 梨膏糖积分奖励计算
        //updateUserIntegral(order.getUserId(), order.getIntegralPrice().doubleValue());

        //设置支付宝订单编号
        order.setPayId(param.getTradeNo());

        order.setPayTime(LocalDateTime.now());

        order.setOrderStatus(OrderUtil.STATUS_PAY);

        if (orderService.updateWithOptimisticLocker(order) == 0) {
            return WxPayNotifyResponse.fail("更新数据已失效");
        }

        //  支付成功，有团购信息，更新团购信息
        LitemallGroupon groupon = grouponService.queryByOrderId(order.getId());
        if (groupon != null) {
            LitemallGrouponRules grouponRules = grouponRulesService.findById(groupon.getRulesId());

            //仅当发起者才创建分享图片
            if (groupon.getGrouponId() == 0) {
                String url = qCodeService.createGrouponShareImage(grouponRules.getGoodsName(), grouponRules.getPicUrl(), groupon);
                groupon.setShareUrl(url);
            }
            groupon.setStatus(GrouponConstant.STATUS_ON);
            if (grouponService.updateById(groupon) == 0) {
                return WxPayNotifyResponse.fail("更新数据已失效");
            }


            List<LitemallGroupon> grouponList = grouponService.queryJoinRecord(groupon.getGrouponId());
            if (groupon.getGrouponId() != 0 && (grouponList.size() >= grouponRules.getDiscountMember() - 1)) {
                for (LitemallGroupon grouponActivity : grouponList) {
                    grouponActivity.setStatus(GrouponConstant.STATUS_SUCCEED);
                    grouponService.updateById(grouponActivity);
                }

                LitemallGroupon grouponSource = grouponService.queryById(groupon.getGrouponId());
                grouponSource.setStatus(GrouponConstant.STATUS_SUCCEED);
                grouponService.updateById(grouponSource);
            }
        }

        //TODO 发送邮件和短信通知，这里采用异步发送
        // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
        // notifyService.notifyMail("新订单通知", order.toString());
        // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
        // notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{outTradeNo.substring(8, 14)});

        // 取消订单超时未支付任务
        taskService.removeTask(new OrderUnpaidTask(order.getId()));

        return WxPayNotifyResponse.success("处理成功!");

    }


    public Object updateStatus(Integer userId, String body, HttpServletRequest request) {

        String chenkOrderId = JacksonUtil.parseString(body, "orderId");
        Integer orderId = Integer.parseInt(chenkOrderId);


        //从支付宝返回的信息中获取订单编号
        // String outTradeNo = param.getOutTradeNo();


        //LitemallOrder order = orderService.findBySn(outTradeNo);
        // int  userId=order.getUserId();


        LitemallOrder order = orderService.findById(orderId);


        //TODO 发送邮件和短信通知，这里采用异步发送
        // 订单支付成功以后，会发送短信给用户，以及发送邮件给管理员
        // notifyService.notifyMail("新订单通知", order.toString());
        // 这里微信的短信平台对参数长度有限制，所以将订单号只截取后6位
        // notifyService.notifySmsTemplateSync(order.getMobile(), NotifyType.PAY_SUCCEED, new String[]{outTradeNo.substring(8, 14)});

        // 取消订单超时未支付任务
        taskService.removeTask(new OrderUnpaidTask(order.getId()));

        return WxPayNotifyResponse.success("处理成功!");

    }


    public Object Test() {


        LitemallOrder order = orderService.findBySn("20220721562457");


        if (order == null) {
            logger.info("########查询订单为空！########");
            return null;
        }
/*******   为了防止出现并发 ，使用lock锁住 下面的内容         ***************/
        try {
            lock.lock();


            int orderid = order.getId();
            int userId = order.getUserId();
            System.out.println(userId+"我的id");
            // 货品价格
            //   List<LitemallCart> checkedGoodsList = cartService.queryByUidAndChecked(userId);

            List<LitemallOrderGoods> litemallOrderGoods = orderGoodsService.selectByorderid(order.getId());
            for (LitemallOrderGoods litss:litemallOrderGoods
                 ) {
                System.out.println(litss.getGoodsName());
            }
            /** 转 fsp  sun   ***********************************/

//String  userIds=""+userId;

//当前用户信息
            LitemallUser my = userService.findById(userId);


/***** 个人业绩  *************************************************************************************************************/
            LitemallUser isyeji = new LitemallUser();
            isyeji.setId(my.getId());
            isyeji.setMypay(Double.parseDouble(order.getActualPrice().toString()));
            userService.updateUserMoney(isyeji);


/***** **********************************************************************************************************/

            /**
             * 如果是 消费券的支付类型 ，先判断消费券 够不够
             * **/
/*if(1==paytype){

    //消费券  - 实际支付金额
    if(my.getXiaofeiquan() - Double.parseDouble(  actualPrice.toString())   > 0){


    }else {

        return ResponseUtil.fail(503, "优惠券不足！当前优惠券剩余："+my.getXiaofeiquan() +",实际支付金额为"+ Double.parseDouble(  actualPrice.toString()) );

    }

}*/


/***** 订单添加成功 ，把订单的数据写到 FSP   **************************************************************************************************************/
            double fsp = 0.00;
            double fspt = 0.00;

            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {

                int spid = cartGoods.getGoodsId();
                //当前商品备受
                int beishu = litemallGoodsService.getbeishu(spid);
                if (beishu != 1) {
                    // fsp =fsp+ 商品价格 x 商品数量      fspt =fspt+ 商品价格 x 商品数量 x 商品倍数 -1

                    fspt = fspt + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()) * (beishu - 1));
                }
                fsp = fsp + (Double.parseDouble(cartGoods.getPrice().toString()) * Integer.parseInt(cartGoods.getNumber().toString()));
            }
            LitemallUser litemallUser = new LitemallUser();
            litemallUser.setId(userId);
            litemallUser.setFSP(fsp);
            litemallUser.setFSPT(fspt);
            userService.updateUserMoney(litemallUser);
/***  录入日志   **/
            litemallMoneyLogService.insertMoney(0, fsp, "用户购买商品，获得FSP", userId, "FSP", 4, my.getFSP() + fsp, orderid);
            if (fspt != 0) {
                litemallMoneyLogService.insertMoney(0, fspt, "用户购买商品，获得FST", userId, "FST", 4, my.getFSPT() + fspt, orderid);
            }
/*****/

/*****   ***************************************************************************************************************************** *****/




//用户链

            String[] userlianarr = my.getUserlian().split(",");
/** 我的等级 **/
            int myleave = my.getUserLevel();



/***** 管理奖    **************************************************************************************************************/
            if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());

                for (int i = 0; i < userlianarr.length; i++) {
// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
                    if (userlianarr.length - i == 1) {
                        break;
                    }
                    /***出现同级次数*/
                    int cha = 0;
                    //当前用户
                    int nowuserid = Integer.parseInt(userlianarr[i]);
                    LitemallUser litemallUsersum = userService.findById(nowuserid);

                    double nowsun = litemallUsersum.getSUN();
                    double nowfsp = litemallUsersum.getFSP();
                    double nowfst = litemallUsersum.getFSPT();
//当前用户等级 从最大等级开始
                    int leave = litemallUsersum.getUserLevel();
                    if (leave == 0) {
                        continue;
                    }

/** 差级, 0 代表平级 ,负数代表 没有团队奖励金***/
                    int cleave = leave - myleave;


/***  最大链 - 本人 不等于 -  则代表 是可以发管理奖的 **/
                    //         System.out.println(String.format("当前购买用户等级 %s  , for的当前等级 %s ，当前用户%s ",myleave,leave,litemallUsersum.getUsername()));
                    if (cleave >= 0) {
                        /**
                         * 是否 进行 fst 转 fsp   1 转  ，0  不转 ,isglj   =当前用户 的管理奖
                         */
                        int fstzfsp = 0;
                        double  isglj=0;
                        //     System.out.println("当前等级"+leave +",当前用户是"+litemallUsersum.getUsername());
                        /** 判断当前 最大链 还有下一位  假设 3人   012    如果是第二位 i=1 结果等于 2 进入else*/
                        if (userlianarr.length - i > 2) {
                            //         System.out.println(String.format("当前的人 的 下一位 不是本人"));
                            /**** 5555  22  0  0    ****/
                            // 当前用户的下一用户  当前是 第一次 是5
                            int nextuserid = Integer.parseInt(userlianarr[i + 1]);
                            LitemallUser litemallUsersumnext = userService.findById(nextuserid);
// 当前用户的 下一用户等级   是 第二个 5
                            int nextleave = litemallUsersumnext.getUserLevel();
                            int gljbs = leave - nextleave > 0 ? leave - nextleave : 1;
                            /**** 5555  22  0  0    ****/
                            /***  出现当前和下一个都是5  55  然后需要判断下一个 是不是还是 5  ***/
                            if (nextleave == leave) {
                                //    System.out.println(String.format("出现同级"));
                                /*** 假设9个人  8人获得奖金   5555  22   00  本人 , 从当前最大人数开始便利 ***/
                                // 下下一用户   两个5  以后 ，第三个用户
                                int nnextuserid = Integer.parseInt(userlianarr[i + 2]);
                                LitemallUser litemallUsersumnextn = userService.findById(nnextuserid);
                                //下下一用户等级
                                int nnextleave = litemallUsersumnextn.getUserLevel();
                                /***  如果 第三个是  5    ，那么代表 当前的 第一个5  是没有奖励金的 ，直接退出循环 ***/
                                if (nextleave == nnextleave) {
                                    continue;
                                } else {
                                    cha = 1;
                                    double sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.1);
                                    isglj=sunglj;
                                    if (nowfsp == 0 && nowfst == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);
                                        litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        continue;
                                    }
                                    if (nowfst-sunglj>=0){
                                        /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
                                        userService.MoneyProup(nowuserid,sunglj,2);
                                        userService.MoneyProdown(nowuserid,sunglj,1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                        /*****/
                                        //当前有多余的fst  可以进入fst转 fsp
                                        if (nowfst - nowsun > 0) {
                                            fstzfsp = 1;
                                        }

                                    }else {
                                        //不够扣  , 如果有 fstp  ,先扣到0
                                        if (nowfst > 0) {
                                            /**   //减FSPT  **/
                                            userService.MoneyProdown(nowuserid, nowfst, 1);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                            /**   //加SUN **/
                                            userService.MoneyProup(nowuserid, nowfst, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                            /*****/
                                            //总数 -扣掉的FSPT
                                            sunglj = sunglj - nowfst;
                                            if (nowfsp == 0) {
                                                /**
                                                 ** 记录完全没有钱的 亏损
                                                 */
                                                userService.MoneyProup(nowuserid, sunglj, 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                continue;
                                            }
                                            //判断 fsp 是否 够扣
                                            if (nowfsp - sunglj < 0) {
                                                /**
                                                 * 记录亏损
                                                 */
                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                //不够扣，有多少 扣多少
                                                sunglj = nowfsp;
                                            }
                                            /**  //减FSP  */
                                            userService.MoneyProdown(nowuserid, sunglj, 0);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                            /****   //加SUN */
                                            userService.MoneyProup(nowuserid, sunglj, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                            /*****/
                                        } else {
                                            //不够扣  , 且没有fst
                                            if (nowfsp == 0) {
                                                /**
                                                 ** 记录完全没有钱的 亏损
                                                 */
                                                userService.MoneyProup(nowuserid, sunglj, 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                continue;
                                            }
                                            //判断 fsp 是否 够扣
                                            if (nowfsp - sunglj < 0) {
                                                /**
                                                 * 记录亏损
                                                 */
                                                userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                                litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                                //不够扣，有多少 扣多少
                                                sunglj = nowfsp;
                                            }
                                            /**  //减FSP  */
                                            userService.MoneyProdown(nowuserid, sunglj, 0);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                            /****   //加SUN */
                                            userService.MoneyProup(nowuserid, sunglj, 2);
                                            /***  录入日志   **/
                                            litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                        }
                                    }
                                }
                            } else {
                                /** 给奖励金 sun  例如  5   5  4    当前是第二个5  或者    543  的第一个 5 **/
                                double sunglj =0.00;
                                if (cha == 1) {
                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)) * 0.9);
                                    isglj=sunglj;
                                } else {
                                    sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (gljbs)));
                                    isglj=sunglj;
                                }
                                if (nowfsp == 0 && nowfst == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(nowuserid, sunglj, 5);
                                    litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                    continue;
                                }
                                if (nowfst-sunglj>=0){
                                    /** 如果 第三个是   554  是4     则当前用户  是  4 级 的上上级，存在有奖励金 的 第二级 **/
                                    userService.MoneyProup(nowuserid,sunglj,2);
                                    userService.MoneyProdown(nowuserid,sunglj,1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                    /*****/
                                    //当前有多余的fst  可以进入fst转 fsp
                                    if (nowfst - nowsun > 0) {
                                        fstzfsp = 1;
                                    }

                                }else {
                                    //不够扣  , 如果有 fstp  ,先扣到0
                                    if (nowfst > 0) {
                                        /**   //减FSPT  **/
                                        userService.MoneyProdown(nowuserid, nowfst, 1);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                        /**   //加SUN **/
                                        userService.MoneyProup(nowuserid, nowfst, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                        /*****/
                                        //总数 -扣掉的FSPT
                                        sunglj = sunglj - nowfst;

                                        if (nowfsp == 0) {
                                            /**
                                             ** 记录完全没有钱的 亏损
                                             */
                                            userService.MoneyProup(nowuserid, sunglj, 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            continue;
                                        }
                                        //判断 fsp 是否 够扣
                                        if (nowfsp - sunglj < 0) {
                                            /**
                                             * 记录亏损
                                             */
                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            //不够扣，有多少 扣多少
                                            sunglj = nowfsp;
                                        }
                                        /**  //减FSP  */
                                        userService.MoneyProdown(nowuserid, sunglj, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                        //加SUN */
                                        userService.MoneyProup(nowuserid, sunglj, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                        /*****/

                                    } else {
                                        //不够扣  , 且没有fst
                                        if (nowfsp == 0) {
                                            /**
                                             ** 记录完全没有钱的 亏损
                                             */
                                            userService.MoneyProup(nowuserid, sunglj, 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            continue;
                                        }
                                        //判断 fsp 是否 够扣
                                        if (nowfsp - sunglj < 0) {
                                            /**
                                             * 记录亏损
                                             */
                                            userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                            litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                            //不够扣，有多少 扣多少
                                            sunglj = nowfsp;
                                        }
                                        /**  //减FSP  */
                                        userService.MoneyProdown(nowuserid, sunglj, 0);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                        /****   //加SUN */
                                        userService.MoneyProup(nowuserid, sunglj, 2);
                                        /***  录入日志   **/
                                        litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                    }
                                }

                            }
                        } else {
                            double sunglj =0.00;
                            if (cha == 1) {
                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)) * 0.9);
                                isglj=sunglj;
                            } else {
                                sunglj = (OrderPrices * ((Double.parseDouble(litemallBaseService.selectBybasetype("管理奖", leave)) * 0.01) * (litemallUsersum.getUserLevel()-myleave)));
                                isglj=sunglj;
                            }
                            if (nowfsp == 0 && nowfst == 0) {
                                /**
                                 ** 记录完全没有钱的 亏损
                                 */
                                userService.MoneyProup(nowuserid, sunglj, 5);
                                litemallMoneyLogService.insertMoney(0,sunglj, "管理人完全没有FST与FSP产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                continue;
                            }
                            if (nowfst-sunglj>=0){
                                userService.MoneyProup(nowuserid,sunglj,2);
                                userService.MoneyProdown(nowuserid,sunglj,1);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(sunglj,0 , "团队获得管理奖，失去FST", litemallUsersum.getId(), "FST", 5, nowfst - sunglj, orderid);
                                litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，转换SUN", litemallUsersum.getId(), "SUN", 5, nowsun + sunglj, orderid);
                                /*****/
                                //当前有多余的fst  可以进入fst转 fsp
                                if (nowfst - nowsun > 0) {
                                    fstzfsp = 1;
                                }

                            }else {
                                //不够扣  , 如果有 fstp  ,先扣到0
                                if (nowfst > 0) {

                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, nowfst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(nowfst, 0, "团队获得管理奖,失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                    /**   //加SUN **/
                                    userService.MoneyProup(nowuserid, nowfst, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, nowfst, "团队获得管理奖,FST转SUN", nowuserid, "SUN", 5, nowsun + nowfst, orderid);
                                    /*****/
                                    //总数 -扣掉的FSPT
                                    sunglj = sunglj - nowfst;
                                    if (nowfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);

                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);

                                        continue;
                                    }
                                    //判断 fsp 是否 够扣
                                    if (nowfsp - sunglj < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        sunglj = nowfsp;
                                    }
                                    /**  //减FSP  */
                                    userService.MoneyProdown(nowuserid, sunglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖,失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                    /****   //加SUN */
                                    userService.MoneyProup(nowuserid, sunglj, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖,，FSP转SUN", nowuserid, "SUN", 5, nowsun + nowfst + sunglj, orderid);
                                    /*****/

                                } else {
                                    //不够扣  , 且没有fst
                                    if (nowfsp == 0) {
                                        /**
                                         ** 记录完全没有钱的 亏损
                                         */
                                        userService.MoneyProup(nowuserid, sunglj, 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        continue;
                                    }
                                    //判断 fsp 是否 够扣
                                    if (nowfsp - sunglj < 0) {
                                        /**
                                         * 记录亏损
                                         */
                                        userService.MoneyProup(nowuserid, Math.abs(nowfsp - sunglj), 5);
                                        litemallMoneyLogService.insertMoney(0, Math.abs(nowfsp - sunglj), "团队获得管理奖,FSP转SUN时，产生的亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                        //不够扣，有多少 扣多少
                                        sunglj = nowfsp;
                                    }
                                    /**  //减FSP  */
                                    userService.MoneyProdown(nowuserid, sunglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(sunglj, 0, "团队获得管理奖，失去FSP", nowuserid, "FSP", 5, nowfsp - sunglj, orderid);
                                    /****   //加SUN */
                                    userService.MoneyProup(nowuserid, sunglj, 2);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, sunglj, "团队获得管理奖，FSP转SUN", nowuserid, "SUN", 5, nowsun + sunglj, orderid);
                                }
                            }


                        }


                        /**
                         * 开始将 fst 转 fsp
                         */
                        if (fstzfsp == 1) {
                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
                            /**
                             * 从新查，并且要大于零
                             */
                            if (getfsp.getFSPT() > 0) {
                                double twofst = getfsp.getFSPT();
                                double twofsp = getfsp.getFSP();

                                if (twofst - isglj >= 0) {
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, isglj, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(isglj, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, twofst - isglj, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(nowuserid, isglj, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, isglj, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofsp + isglj, orderid);
                                    /*****/

                                } else {
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - isglj), 0, "团队获得管理奖，产生FSP亏损", nowuserid, "亏损", 5, 0.00, orderid);
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(nowuserid, twofst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(twofst, 0, "团队获得管理奖，失去FST", nowuserid, "FST", 5, 0.00, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(nowuserid, twofst, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, twofst, "团队获得管理奖，FST转FSP", nowuserid, "FSP", 5, twofst + twofsp, orderid);
                                    /*****/
                                }

                            }
                        }






                    }

                }

            }

            /*************************************************************************************************************************************************
             * 直推 ，间推
             */

            if (userlianarr.length > 1 && !String.valueOf(userId).equals(userlianarr[0])) {
                //订单总费用 =   实际 商品总金额  + 运费 减优惠券
                double OrderPrices = Double.parseDouble(order.getOrderPrice().toString());

                for (int i = 0; i < userlianarr.length; i++) {
// 最高级用户 -----》一直到  我 ,而且如果是我，就跳出
                    if (userlianarr.length - i == 1) {
                        break;
                    }
                    //当前用户
                    int nowuserid = Integer.parseInt(userlianarr[i]);
                    LitemallUser litemallUsersum = userService.findById(nowuserid);

                    double nowsun = litemallUsersum.getSUN();

                    //倍率
                    double nowbeilv = 0.00;
//当前用户等级 从最大等级开始
                    int leave = litemallUsersum.getUserLevel();
                    if (userlianarr.length - i <= 3) {
                        //计算当前倍率
                        //直推
                        /**
                         * 是否 进行 fst 转 fsp   1 转  ，0  不转
                         */
                        int fstzfsp = 0;
                        int zmt = 0;
                        if (userlianarr.length - i == 2) {
                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("直推", leave)) * 0.01;
                            zmt = 1;
                        } else {
                            //间接推
                            nowbeilv = Double.parseDouble(litemallBaseService.selectBybasetype("间推", leave)) * 0.01;
                            zmt = 2;
                        }
                        //当前用户获得的佣金 SUM
                        double mysum = OrderPrices * nowbeilv;
                        int myid = litemallUsersum.getId();
                        double myfsp = litemallUsersum.getFSP();
                        double myfspt = litemallUsersum.getFSPT();
//当前用户没有钱   跳下一用户
                        if (litemallUsersum.getFSP() == 0 && litemallUsersum.getFSPT() == 0) {
                            /**
                             ** 记录完全没有钱的 亏损
                             */
                            userService.MoneyProup(myid, mysum, 5);

                            litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人完全没有FST与FSP产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                            continue;
                        }
                        //优先完成 sun的转换
                        //先扣 FSPT   ，如果FSPT够 扣
                        if (myfspt - mysum >= 0) {

                            /**   //减FSPT  **/
                            userService.MoneyProdown(myid, mysum, 1);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,，失去FST", myid, "FST", zmt, myfspt - mysum, orderid);
                            /*****/
                            /**   //加SUN **/
                            userService.MoneyProup(myid, mysum, 2);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
                            /*****/
//当前有多余的fst  可以进入fst转 fsp
                            if (myfspt - mysum > 0) {
                                fstzfsp = 1;
                            }

                        } else {
                            //不够扣  , 如果有 fstp  ,先扣到0
                            if (myfspt > 0) {

                                /**   //减FSPT  **/
                                userService.MoneyProdown(myid, myfspt, 1);

                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(myfspt, 0, "推荐人获得奖励,失去FST", myid, "FST", zmt, 0.00, orderid);
                                /*****/

                                /**   //加SUN **/
                                userService.MoneyProup(myid, myfspt, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, myfspt, "推荐人获得奖励,FST转SUN", myid, "SUN", zmt, nowsun + myfspt, orderid);
                                /*****/
                                //总数 -扣掉的FSPT
                                mysum = mysum - myfspt;

                                if (myfsp == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(myid, mysum, 5);

                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                                    continue;
                                }
                                //判断 fsp 是否 够扣
                                if (myfsp - mysum < 0) {
                                    /**
                                     * 记录亏损
                                     */
                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
                                    //不够扣，有多少 扣多少
                                    mysum = myfsp;
                                }
                                /**  //减FSP  */
                                userService.MoneyProdown(myid, mysum, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励,失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
                                /*****/
/****   //加SUN */
                                userService.MoneyProup(myid, mysum, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励,，FSP转SUN", myid, "SUN", zmt, nowsun + myfspt + mysum, orderid);
                                /*****/

                            } else {
                                //不够扣  , 且没有fst
                                if (myfsp == 0) {
                                    /**
                                     ** 记录完全没有钱的 亏损
                                     */
                                    userService.MoneyProup(myid, mysum, 5);

                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);

                                    continue;
                                }
                                //判断 fsp 是否 够扣
                                if (myfsp - mysum < 0) {
                                    /**
                                     * 记录亏损
                                     */
                                    userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                    litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "推荐人获得奖励,FSP转SUN时，产生的亏损", myid, "亏损", zmt, 0.00, orderid);
                                    //不够扣，有多少 扣多少
                                    mysum = myfsp;
                                }
                                /**  //减FSP  */
                                userService.MoneyProdown(myid, mysum, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FSP", myid, "FSP", zmt, myfsp - mysum, orderid);
                                /*****/
/****   //加SUN */
                                userService.MoneyProup(myid, mysum, 2);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FSP转SUN", myid, "SUN", zmt, nowsun + mysum, orderid);
                                /*****/

                            }

                        }

                        /**
                         * 开始将 fst 转 fsp
                         */
                        if (fstzfsp == 1) {
                            LitemallUser getfsp = userService.findById(litemallUsersum.getId());
                            /**
                             * 从新查，并且要大于零
                             */
                            if (getfsp.getFSPT() > 0) {
                                double twofst = getfsp.getFSPT();
                                double twofsp = getfsp.getFSP();

                                if (twofst - mysum >= 0) {
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(myid, mysum, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(mysum, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, twofst - mysum, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(myid, mysum, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, mysum, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofsp + mysum, orderid);
                                    /*****/

                                } else {
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "推荐人获得奖励，产生FSP亏损", myid, "亏损", zmt, 0.00, orderid);
                                    /**   //减FSPT  **/
                                    userService.MoneyProdown(myid, twofst, 1);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(twofst, 0, "推荐人获得奖励，失去FST", myid, "FST", zmt, 0.00, orderid);
                                    /*****/
                                    /**   //加FSP **/
                                    userService.MoneyProup(myid, twofst, 0);
                                    /***  录入日志   **/
                                    litemallMoneyLogService.insertMoney(0, twofst, "推荐人获得奖励，FST转FSP", myid, "FSP", zmt, twofst + twofsp, orderid);
                                    /*****/
                                }

                            }
                        }


                    }
                }

            }
/*****   ***************************************************************************************************************************** *****/


/*****  获得 品牌方奖励 **  7.27改*************************************************************************************************************************** *****/


            for (LitemallOrderGoods cartGoods : litemallOrderGoods) {
                //被购买商品获得的奖励
                double mysum = 0.00;
                double fsts = 0.00;
                int spid = cartGoods.getGoodsId();
                //当前品牌方信息
                LitemallUser ppfuser = userService.selectBySPId(spid);
                /**
                 * 是否 进行 fst 转 fsp   1 转  ，0  不转
                 */
                int fstzfsp = 0;
                if (ppfuser != null) {
                    fsts = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBybasetype("商家奖", 0)) * 0.01));
                    LitemallUser setppf = new LitemallUser();
                    setppf.setId(ppfuser.getId());
                    setppf.setFSPT(mysum);
                    userService.updateUserMoney(setppf);

                 //   int myid = ppfuser.getId();
                  //  double myfsp = ppfuser.getFSP();
                //   double myfspt = ppfuser.getFSPT();
                 //   double nowsun = ppfuser.getSUN();
                    /*****************************/

                    /**   //fst **/
                    userService.MoneyProup(ppfuser.getId(), fsts, 1);
                    /***  录入日志   **/
                    litemallMoneyLogService.insertMoney(0, fsts, "商家获得购买商品奖励FST", ppfuser.getId(), "FST", 3,  ppfuser.getFSPT() + fsts, orderid);
                    /*****/

                    String mylian = ppfuser.getUserlian();
                //    System.out.println(mylian+"我的用户链是");
                    String[] lians = mylian.split(",");
                    if ( lians.length >= 2) {
                    //    System.out.println("存在二级链");
                        for (int i = 0;i< lians.length ; i++) {
                            if (i == lians.length - 3) {
                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ003")) *0.01));
                            } else if (i == lians.length - 2) {
                                mysum = (Double.parseDouble(cartGoods.getPrice().toString()) * (Double.parseDouble(litemallBaseService.selectBYnumber("SJ002")) *0.01));
                            } else {
                                continue;
                            }
                            LitemallUser  sjtj=userService.findById(Integer.parseInt(lians[i]));
                     //       System.out.println(sjtj.getNickname());
                              int myid = sjtj.getId();
                             double myfsp = sjtj.getFSP();
                               double myfspt = sjtj.getFSPT();
                              double nowsun = sjtj.getSUN();

                    //先扣 FSPT   ，如果FSPT够 扣
                    if (myfspt - mysum >= 0) {

                        /**   //减FSPT  **/
                        userService.MoneyProdown(myid, mysum, 1);
                        /***  录入日志   **/
                        litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, myfspt - mysum, orderid);
                        /*****/
                        /**   //加SUN **/
                        userService.MoneyProup(myid, mysum, 2);
                        /***  录入日志   **/
                        litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + mysum, orderid);
                        /*****/
                        //当前有多余的fst  可以进入fst转 fsp
                        if (myfspt - mysum > 0) {
                            fstzfsp = 1;
                        }
                    } else {
                        //不够扣  , 如果有 fstp  ,先扣到0
                        if (myfspt > 0) {

                            /**   //减FSPT  **/
                            userService.MoneyProdown(myid, myfspt, 1);

                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(myfspt, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
                            /*****/

                            /**   //加SUN **/
                            userService.MoneyProup(myid, myfspt, 2);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(0, myfspt, "商家推荐人获得购买商品奖励，FST转SUN", myid, "SUN", 3, nowsun + myfspt, orderid);
                            /*****/

                            //总数 -扣掉的FSPT
                            mysum = mysum - myfspt;
                            if (myfsp == 0) {
                                /**
                                 ** 记录完全没有钱的 亏损
                                 */
                                userService.MoneyProup(myid, mysum, 5);

                                litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);

                                continue;
                            }

                            //判断 fsp 是否 够扣
                            if (myfsp - mysum < 0) {
                                /**
                                 * 记录亏损
                                 */
                                userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
                                //不够扣，有多少 扣多少
                                mysum = myfsp;
                            }
//扣 ftp
                            /**  //减FSP  */
                            userService.MoneyProdown(myid, mysum, 0);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
                            /*****/
/****   //加SUN */
                            userService.MoneyProup(myid, mysum, 2);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
                            /*****/

                        } else {
                            //不够扣  , 且没有fst
                            if (myfsp == 0) {
                                /**
                                 ** 记录完全没有钱的 亏损
                                 */
                                userService.MoneyProup(myid, mysum, 5);

                                litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);

                                continue;
                            }
                            //判断 fsp 是否 够扣
                            if (myfsp - mysum < 0) {
                                /**
                                 * 记录亏损
                                 */
                                userService.MoneyProup(myid, Math.abs(myfsp - mysum), 5);
                                litemallMoneyLogService.insertMoney(0, Math.abs(myfsp - mysum), "商家推荐人FSP转SUN时，产生的亏损", myid, "亏损", 3, 0.00, orderid);
                                //不够扣，有多少 扣多少
                                mysum = myfsp;
                            }
                            /**  //减FSP  */
                            userService.MoneyProdown(myid, mysum, 0);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FSP", myid, "FSP", 3, myfsp - mysum, orderid);
                            /*****/
/****   //加SUN */
                            userService.MoneyProup(myid, mysum, 2);
                            /***  录入日志   **/
                            litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FSP转SUN", myid, "SUN", 3, nowsun + myfspt + mysum, orderid);
                            /*****/

                        }

                    }

                    /**
                     * 开始将 fst 转 fsp
                     */
                    if (fstzfsp == 1) {
                        LitemallUser getfsp = userService.findById(ppfuser.getId());
                        /**
                         * 从新查，并且要大于零
                         */
                        if (getfsp.getFSPT() > 0) {
                            double twofst = getfsp.getFSPT();
                            double twofsp = getfsp.getFSP();

                            if (twofst - mysum >= 0) {
                                /**   //减FSPT  **/
                                userService.MoneyProdown(myid, mysum, 1);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(mysum, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, twofst - mysum, orderid);
                                /*****/
                                /**   //加FSP **/
                                userService.MoneyProup(myid, mysum, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, mysum, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofsp + mysum, orderid);
                                /*****/

                            } else {
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(Math.abs(twofst - mysum), 0, "商家推荐人获得购买商品奖励，产生FSP亏损", myid, "亏损", 3, 0.00, orderid);
                                /**   //减FSPT  **/
                                userService.MoneyProdown(myid, twofst, 1);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(twofst, 0, "商家推荐人获得购买商品奖励，失去FST", myid, "FST", 3, 0.00, orderid);
                                /*****/
                                /**   //加FSP **/
                                userService.MoneyProup(myid, twofst, 0);
                                /***  录入日志   **/
                                litemallMoneyLogService.insertMoney(0, twofst, "商家推荐人获得购买商品奖励，FST转FSP", myid, "FSP", 3, twofst + twofsp, orderid);
                                /*****/
                            }

                        }
                    }

                    /**/
                }}

                }


            }
            /*****   ***************************************************************************************************************************** *****/





        } catch (Exception e) {

        } finally {
            //不管异常，释放锁 防止线程卡死
            lock.unlock();
        }

/*****   ***************************************************************************************************************************** *****/


        return "ok";

    }

    /**
     * 该方法作为支付宝支付成功后，对用户邀请人以及用户链做积分变更的方法
     * @param userId 支付成功的用户id
     * @param integral 支付成功的金额
     */
    public void updateUserIntegral(Integer userId, Double integral,LitemallOrder order) {
        logger.info("触发积分奖励，userId="+userId+",订单金额="+integral);

        if (integral >= 0) {
            LitemallUser direct = null; // 用户的直接邀请人
            LitemallUser indirect = null; // 用户的间接邀请人
            Integer directInviteeId = null; // 用户的直接邀请人id
            Integer indirectInviteeId = null; // 用户的间接邀请人id
            String[] userlian = null; // 用户链
            Integer proProxyId = null; // 省代id
            Integer cityProxyId = null; // 市代id
            Integer coutProxyId = null; // 县代id
            LitemallUser tmpUser; // 代理的临时操作对象
            //以id找出用户
            LitemallUser user = userService.findById(userId);
            if (user != null) {
                //获取直接邀请人和间接邀请人的id
                directInviteeId = user.getDirectInvitee();
                indirectInviteeId = user.getIndirectInvitee();
                //判断是否存在直接邀请人和间接邀请人
                if (directInviteeId != 0 && (direct = userService.findById(directInviteeId)) != null) {
                    // 根据规则用户购买物品时邀请人会得到用户所花费的金额乘以百分之几的积分加成;
                    direct.setIntegral(direct.getIntegral() + integral * 0.06);
                    // 直接保存
                    userService.updateById(direct);
                    //记录积分记录
                    pointsRecordService.inviteeReward(direct.getId(), userId, integral * 0.06,order, "1");
                }

                if (indirectInviteeId != 0 && (indirect = userService.findById(indirectInviteeId)) != null) {
                    indirect.setIntegral(indirect.getIntegral() + integral * 0.04);
                    userService.updateById(indirect);
                    //记录积分记录
                    pointsRecordService.inviteeReward(indirect.getId(), userId, integral * 0.04,order, "2");

                }

                // 处理代理的积分增加
                if (StringUtils.hasText(user.getUserlian()) && (userlian = user.getUserlian().split(",")).length >= 1) {
                    // 遍历每个用户id
                    for (int i = userlian.length - 1; i >= 0; i--) {
                        int proxyId = Integer.parseInt(userlian[i]);
                        boolean flag = false; // 后续做判断，若出现需要保存的代理用户，就更改flag，最后做判断是否保存

                        int level;
                        Double addIntegral = 0d;
                        tmpUser = userService.findById(proxyId); // 根据id找到用户
                        if (tmpUser != null && 0 != (level = tmpUser.getServeCenter())) { // 判断是否是代理
                            if (coutProxyId == null && 3 == level && cityProxyId == null) {
                                addIntegral = integral * 0.05;
                                tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                coutProxyId = proxyId;
                                flag = true;
                            } else if (cityProxyId == null && 2 == level) {
                                if (coutProxyId == null) { // 县代是空，市代拿 3+5=8
                                    addIntegral = integral * 0.08;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    cityProxyId = proxyId;
                                    flag = true;
                                }else {
                                    addIntegral = integral * 0.03;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    cityProxyId = proxyId;
                                    flag = true;
                                }
                            } else if (proProxyId == null && 1 == level) { // 先判断是否已经记录了代理的id，没记录就对该用户做积分奖励
                                if (coutProxyId == null && cityProxyId == null){
                                    addIntegral = integral * 0.1;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    proProxyId = proxyId;// 记录代理用户的id
                                    flag = true; // flag做变动，后续会对该用户保存操作
                                } else if (cityProxyId == null && coutProxyId != null) {
                                    addIntegral = integral * 0.05;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    proProxyId = proxyId;// 记录代理用户的id
                                    flag = true; // flag做变动，后续会对该用户保存操作
                                } else if (coutProxyId != null && cityProxyId != null) {
                                    addIntegral = integral * 0.02;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    proProxyId = proxyId;// 记录代理用户的id
                                    flag = true; // flag做变动，后续会对该用户保存操作
                                } else if (cityProxyId != null && coutProxyId == null) {
                                    addIntegral = integral * 0.02;
                                    tmpUser.setIntegral(tmpUser.getIntegral() + addIntegral);
                                    proProxyId = proxyId;// 记录代理用户的id
                                    flag = true; // flag做变动，后续会对该用户保存操作
                                }
                            }
                            if (flag) {
                                userService.updateById(tmpUser);
                                //增加积分记录
                                pointsRecordService.proxyReward(tmpUser.getId(), userId, addIntegral,order, Integer.toString(level));
                            }
                            if (proProxyId != null) {// 如果已经找到了省代，说明后续不用再找了，直接终结循环
                                break;
                            }
                        }
                    }
                }
            }
        }

    }

    public double handleIntegral(double integral){
        BigDecimal bg = new BigDecimal(integral).setScale(2, RoundingMode.DOWN);
        return bg.doubleValue();
    }



}